principles-disciple 1.126.0 → 1.128.0

package/src/core/control-ui-db.ts

@@ -1,454 +0,0 @@
-import Database from 'better-sqlite3';
-import fs from 'fs';
-import path from 'path';
-import { withLock } from '../utils/file-lock.js';
-import { resolvePdPath } from './paths.js';
-
-/**
- * Control UI database stores ANALYTICS READ MODELS.
- *
- * PURPOSE: Aggregated data for dashboard visualization and historical insights.
- * USAGE: Control UI queries and dashboard displays.
- * NOT FOR: Control decisions, Phase 3 eligibility, or real-time operations.
- *
- * Runtime truth comes from: queue state, workspace trust scorecard, active sessions
- */
-
-export interface ThinkingModelEventInput {
-  sessionId: string;
-  runId: string;
-  assistantTurnId: number;
-  modelId: string;
-  matchedPattern: string;
-  scenarioJson: unknown;
-  toolContextJson: unknown;
-  painContextJson: unknown;
-  principleContextJson: unknown;
-  triggerExcerpt: string;
-  createdAt: string;
-}
-
-export interface ControlUiDatabaseOptions {
-  workspaceDir: string;
-  busyTimeoutMs?: number;
-}
-
-export interface RecentThinkingContext {
-  toolCalls: {
-    id: number;
-    toolName: string;
-    outcome: 'success' | 'failure' | 'blocked';
-    errorType: string | null;
-    errorMessage: string | null;
-    createdAt: string;
-  }[];
-  painEvents: {
-    id: number;
-    source: string;
-    score: number;
-    reason: string | null;
-    createdAt: string;
-  }[];
-  gateBlocks: {
-    id: number;
-    toolName: string;
-    reason: string;
-    filePath: string | null;
-    createdAt: string;
-  }[];
-  userCorrections: {
-    id: number;
-    correctionCue: string | null;
-    rawExcerpt: string | null;
-    createdAt: string;
-  }[];
-  principleEvents: {
-    id: number;
-    principleId: string | null;
-    eventType: string;
-    createdAt: string;
-  }[];
-}
-
-const DEFAULT_BUSY_TIMEOUT_MS = 5000;
-
-function safeJson(value: unknown): string {
-  return JSON.stringify(value ?? []);
-}
-
-export class ControlUiDatabase {
-  private readonly workspaceDir: string;
-  private readonly dbPath: string;
-  private readonly blobDir: string;
-  private readonly db: Database.Database;
-
-  constructor(opts: ControlUiDatabaseOptions) {
-    this.workspaceDir = path.resolve(opts.workspaceDir);
-    this.dbPath = resolvePdPath(this.workspaceDir, 'TRAJECTORY_DB');
-    this.blobDir = resolvePdPath(this.workspaceDir, 'TRAJECTORY_BLOBS_DIR');
-
-    fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
-    fs.mkdirSync(this.blobDir, { recursive: true });
-
-    this.db = new Database(this.dbPath);
-    this.db.pragma('journal_mode = WAL');
-    this.db.pragma('foreign_keys = ON');
-    this.db.pragma('synchronous = NORMAL');
-    this.db.pragma(`busy_timeout = ${Math.max(0, opts.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS)}`);
-    this.initSchema();
-  }
-
-  dispose(): void {
-    this.db.close();
-  }
-
-  recordThinkingModelEvent(input: ThinkingModelEventInput): number {
-    return this.withWrite(() => {
-      const result = this.db.prepare(`
-        INSERT INTO thinking_model_events (
-          session_id, run_id, assistant_turn_id, model_id, matched_pattern, scenario_json,
-          tool_context_json, pain_context_json, principle_context_json, trigger_excerpt, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(
-        input.sessionId,
-        input.runId,
-        input.assistantTurnId,
-        input.modelId,
-        input.matchedPattern,
-        safeJson(input.scenarioJson),
-        safeJson(input.toolContextJson),
-        safeJson(input.painContextJson),
-        safeJson(input.principleContextJson),
-        input.triggerExcerpt,
-        input.createdAt,
-      );
-      return Number(result.lastInsertRowid);
-    });
-  }
-
-  /**
-   * Get recent thinking context for a session.
-   *
-   * Returns: Analytics data (read model) aggregated from trajectory database.
-   * Not: Runtime truth or real-time queue state.
-   */
-  getRecentThinkingContext(sessionId: string, beforeCreatedAt: string, limit = 5): RecentThinkingContext {
-    return {
-      toolCalls: this.all<{
-        id: number;
-        tool_name: string;
-        outcome: 'success' | 'failure' | 'blocked';
-        error_type: string | null;
-        error_message: string | null;
-        created_at: string;
-      }>(
-        `
-          SELECT id, tool_name, outcome, error_type, error_message, created_at
-          FROM tool_calls
-          WHERE session_id = ? AND created_at <= ?
-          ORDER BY created_at DESC
-          LIMIT ?
-        `,
-        sessionId,
-        beforeCreatedAt,
-        limit,
-      ).map((row) => ({
-        id: Number(row.id),
-        toolName: String(row.tool_name),
-        outcome: row.outcome,
-        errorType: row.error_type,
-        errorMessage: row.error_message,
-        createdAt: String(row.created_at),
-      })),
-      painEvents: this.all<{
-        id: number;
-        source: string;
-        score: number;
-        reason: string | null;
-        created_at: string;
-      }>(
-        `
-          SELECT id, source, score, reason, created_at
-          FROM pain_events
-          WHERE session_id = ? AND created_at <= ?
-          ORDER BY created_at DESC
-          LIMIT ?
-        `,
-        sessionId,
-        beforeCreatedAt,
-        limit,
-      ).map((row) => ({
-        id: Number(row.id),
-        source: String(row.source),
-        score: Number(row.score),
-        reason: row.reason,
-        createdAt: String(row.created_at),
-      })),
-      gateBlocks: this.all<{
-        id: number;
-        tool_name: string;
-        reason: string;
-        file_path: string | null;
-        created_at: string;
-      }>(
-        `
-          SELECT id, tool_name, reason, file_path, created_at
-          FROM gate_blocks
-          WHERE session_id = ? AND created_at <= ?
-          ORDER BY created_at DESC
-          LIMIT ?
-        `,
-        sessionId,
-        beforeCreatedAt,
-        limit,
-      ).map((row) => ({
-        id: Number(row.id),
-        toolName: String(row.tool_name),
-        reason: String(row.reason),
-        filePath: row.file_path,
-        createdAt: String(row.created_at),
-      })),
-      userCorrections: this.all<{
-        id: number;
-        correction_cue: string | null;
-        raw_excerpt: string | null;
-        created_at: string;
-      }>(
-        `
-          SELECT id, correction_cue, raw_excerpt, created_at
-          FROM user_turns
-          WHERE session_id = ? AND correction_detected = 1 AND created_at <= ?
-          ORDER BY created_at DESC
-          LIMIT ?
-        `,
-        sessionId,
-        beforeCreatedAt,
-        limit,
-      ).map((row) => ({
-        id: Number(row.id),
-        correctionCue: row.correction_cue,
-        rawExcerpt: row.raw_excerpt,
-        createdAt: String(row.created_at),
-      })),
-      principleEvents: this.all<{
-        id: number;
-        principle_id: string | null;
-        event_type: string;
-        created_at: string;
-      }>(
-        `
-          SELECT id, principle_id, event_type, created_at
-          FROM principle_events
-          WHERE created_at <= ?
-          ORDER BY created_at DESC
-          LIMIT ?
-        `,
-        beforeCreatedAt,
-        limit,
-      ).map((row) => ({
-        id: Number(row.id),
-        principleId: row.principle_id,
-        eventType: String(row.event_type),
-        createdAt: String(row.created_at),
-      })),
-    };
-  }
-
-  /**
-   * Execute SQL query and return all rows.
-   *
-   * Returns: Analytics data (read model) aggregated from trajectory database.
-   * Not: Runtime truth or real-time queue state.
-   */
-  all<T>(sql: string, ...params: unknown[]): T[] {
-    return this.db.prepare(sql).all(...params) as T[];
-  }
-
-  /**
-   * Execute SQL query and return first row.
-   *
-   * Returns: Analytics data (read model) aggregated from trajectory database.
-   * Not: Runtime truth or real-time queue state.
-   */
-  get<T>(sql: string, ...params: unknown[]): T | undefined {
-    return this.db.prepare(sql).get(...params) as T | undefined;
-  }
-
-  /**
-   * Execute SQL statement that does not return rows (DDL, CREATE TABLE, etc.).
-   *
-   * Returns: void (executes directly)
-   * Not for: SELECT queries (use all() or get() instead)
-   */
-  execute(sql: string): void {
-    this.db.exec(sql);
-  }
-
-  /**
-   * Execute a parameterized write statement (INSERT, UPDATE, DELETE).
-   */
-  run(sql: string, ...params: unknown[]): void {
-    this.withWrite(() => {
-      this.db.prepare(sql).run(...params);
-    });
-  }
-
-  restoreRawText(inlineText?: string | null, blobRef?: string | null): string {
-    if (inlineText) return inlineText;
-    if (!blobRef) return '';
-    const fullPath = path.join(this.blobDir, blobRef);
-    return fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : '';
-  }
-
-  private initSchema(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS thinking_model_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        run_id TEXT NOT NULL,
-        assistant_turn_id INTEGER NOT NULL,
-        model_id TEXT NOT NULL,
-        matched_pattern TEXT NOT NULL,
-        scenario_json TEXT NOT NULL,
-        tool_context_json TEXT NOT NULL,
-        pain_context_json TEXT NOT NULL,
-        principle_context_json TEXT NOT NULL,
-        trigger_excerpt TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_model_created
-        ON thinking_model_events(model_id, created_at);
-      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_session_created
-        ON thinking_model_events(session_id, created_at);
-      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_assistant_turn
-        ON thinking_model_events(assistant_turn_id);
-      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_run_id
-        ON thinking_model_events(run_id);
-
-      DROP VIEW IF EXISTS v_thinking_model_usage;
-      CREATE VIEW v_thinking_model_usage AS
-      WITH totals AS (
-        SELECT COUNT(*) AS assistant_turns FROM assistant_turns
-      ),
-      usage_rows AS (
-        SELECT
-          model_id,
-          COUNT(*) AS hits,
-          COUNT(DISTINCT session_id) AS distinct_sessions,
-          COUNT(DISTINCT assistant_turn_id) AS distinct_turns
-        FROM thinking_model_events
-        GROUP BY model_id
-      )
-      SELECT
-        usage_rows.model_id AS model_id,
-        usage_rows.hits AS hits,
-        usage_rows.distinct_sessions AS distinct_sessions,
-        usage_rows.distinct_turns AS distinct_turns,
-        CASE
-          WHEN totals.assistant_turns = 0 THEN 0
-          ELSE ROUND(CAST(usage_rows.distinct_turns AS REAL) / CAST(totals.assistant_turns AS REAL), 4)
-        END AS coverage_rate
-      FROM usage_rows, totals
-      ORDER BY usage_rows.hits DESC, usage_rows.model_id ASC;
-
-      DROP VIEW IF EXISTS v_thinking_model_effectiveness;
-      CREATE VIEW v_thinking_model_effectiveness AS
-      WITH event_windows AS (
-        SELECT
-          e.id,
-          e.session_id,
-          e.model_id,
-          e.created_at,
-          (
-            SELECT MIN(a.created_at)
-            FROM assistant_turns a
-            WHERE a.session_id = e.session_id AND a.created_at > e.created_at
-          ) AS next_assistant_at,
-          datetime(e.created_at, '+10 minutes') AS max_window_end
-        FROM thinking_model_events e
-      ),
-      bounded_windows AS (
-        SELECT
-          id,
-          session_id,
-          model_id,
-          created_at,
-          CASE
-            WHEN next_assistant_at IS NULL THEN max_window_end
-            WHEN next_assistant_at < max_window_end THEN next_assistant_at
-            ELSE max_window_end
-          END AS window_end
-        FROM event_windows
-      )
-      SELECT
-        b.model_id AS model_id,
-        COUNT(*) AS events,
-        SUM(CASE WHEN EXISTS (
-          SELECT 1 FROM tool_calls t
-          WHERE t.session_id = b.session_id
-            AND t.created_at > b.created_at
-            AND t.created_at <= b.window_end
-            AND t.outcome = 'success'
-        ) THEN 1 ELSE 0 END) AS success_windows,
-        SUM(CASE WHEN EXISTS (
-          SELECT 1 FROM tool_calls t
-          WHERE t.session_id = b.session_id
-            AND t.created_at > b.created_at
-            AND t.created_at <= b.window_end
-            AND t.outcome = 'failure'
-        ) THEN 1 ELSE 0 END) AS failure_windows,
-        SUM(CASE WHEN EXISTS (
-          SELECT 1 FROM pain_events p
-          WHERE p.session_id = b.session_id
-            AND p.created_at > b.created_at
-            AND p.created_at <= b.window_end
-        ) THEN 1 ELSE 0 END) AS pain_windows,
-        SUM(CASE WHEN EXISTS (
-          SELECT 1 FROM user_turns u
-          WHERE u.session_id = b.session_id
-            AND u.created_at > b.created_at
-            AND u.created_at <= b.window_end
-            AND u.correction_detected = 1
-        ) THEN 1 ELSE 0 END) AS correction_windows,
-        SUM(CASE WHEN EXISTS (
-          SELECT 1 FROM correction_samples c
-          WHERE c.session_id = b.session_id
-            AND c.created_at > b.created_at
-            AND c.created_at <= b.window_end
-        ) THEN 1 ELSE 0 END) AS correction_sample_windows
-      FROM bounded_windows b
-      GROUP BY b.model_id
-      ORDER BY events DESC, model_id ASC;
-
-      DROP VIEW IF EXISTS v_thinking_model_scenarios;
-      CREATE VIEW v_thinking_model_scenarios AS
-      SELECT
-        e.model_id AS model_id,
-        CAST(j.value AS TEXT) AS scenario,
-        COUNT(*) AS hits
-      FROM thinking_model_events e
-      JOIN json_each(
-        CASE
-          WHEN json_valid(e.scenario_json) THEN e.scenario_json
-          ELSE '[]'
-        END
-      ) AS j
-      GROUP BY e.model_id, CAST(j.value AS TEXT)
-      ORDER BY hits DESC, scenario ASC;
-
-      DROP VIEW IF EXISTS v_thinking_model_daily_trend;
-      CREATE VIEW v_thinking_model_daily_trend AS
-      SELECT
-        substr(created_at, 1, 10) AS day,
-        model_id,
-        COUNT(*) AS hits
-      FROM thinking_model_events
-      GROUP BY substr(created_at, 1, 10), model_id
-      ORDER BY day ASC, model_id ASC;
-    `);
-  }
-
-  private withWrite<T>(fn: () => T): T {
-    return withLock(this.dbPath, fn, { lockSuffix: '.trajectory.lock', lockStaleMs: 30000 });
-  }
-}

package/src/core/correction-cue-learner.ts

@@ -1,239 +0,0 @@
-/**
- * Correction Cue Learner
- *
- * Persistent, learnable keyword store for correction cue detection.
- * Replaces the hardcoded cue list in detectCorrectionCue() with a
- * crash-safe JSON store that can grow over time.
- *
- * Persistence contract:
- *   - Atomic write: temp-file-then-rename (T-38-02)
- *   - Cache invalidated after every write (D-05)
- *   - 200-term hard cap enforced before any write (T-38-01)
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type {
-  CorrectionKeyword,
-  CorrectionKeywordStore,
-  CorrectionMatchResult} from './correction-types.js';
-import {
-  CORRECTION_SEED_KEYWORDS,
-  MAX_CORRECTION_KEYWORDS,
-} from './correction-types.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-
-const KEYWORD_STORE_FILE = 'correction_keywords.json';
-
-const MIN_KEYWORD_WEIGHT = 0.1;
-const MAX_KEYWORD_WEIGHT = 0.9;
-
-let _correctionCueCache: CorrectionKeywordStore | null = null;
-
-export function _resetCorrectionCueCache(): void {
-  _correctionCueCache = null;
-}
-
-function createDefaultStore(): CorrectionKeywordStore {
-  const now = new Date().toISOString();
-  const keywords: CorrectionKeyword[] = CORRECTION_SEED_KEYWORDS.map((k) => ({
-    ...k,
-    source: 'seed' as const,
-    addedAt: now,
-  }));
-  return { keywords, version: 1, lastOptimizedAt: now };
-}
-
-export function loadCorrectionKeywordStore(stateDir: string): CorrectionKeywordStore {
-  if (_correctionCueCache) return _correctionCueCache;
-
-  const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
-
-  if (fs.existsSync(filePath)) {
-    try {
-      const raw = fs.readFileSync(filePath, 'utf-8');
-      _correctionCueCache = JSON.parse(raw) as CorrectionKeywordStore;
-      return _correctionCueCache;
-    } catch {
-      void 0;
-    }
-  }
-
-  const defaultStore = createDefaultStore();
-  saveCorrectionKeywordStore(stateDir, defaultStore);
-  _correctionCueCache = defaultStore;
-  return _correctionCueCache;
-}
-
-export function saveCorrectionKeywordStore(
-  stateDir: string,
-  store: CorrectionKeywordStore
-): void {
-  const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
-
-  fs.mkdirSync(stateDir, { recursive: true });
-  atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
-
-  _correctionCueCache = null;
-}
-
-let _instance: CorrectionCueLearner | null = null;
-let _lastStateDir: string | null = null;
-
-export function _resetCorrectionCueLearnerInstance(): void {
-  _instance = null;
-  _lastStateDir = null;
-}
-
-export class CorrectionCueLearner {
-  private readonly store: CorrectionKeywordStore;
-  private readonly stateDir: string;
-
-  constructor(stateDir: string) {
-    this.stateDir = stateDir;
-    this.store = loadCorrectionKeywordStore(stateDir);
-  }
-
-  match(text: string): CorrectionMatchResult {
-    const normalized = text
-      .trim()
-      .toLowerCase()
-      .replace(/[.,!?;:，。！？；：]/g, '');
-
-    const matchedTerms: string[] = [];
-    let totalScore = 0;
-
-    for (const keyword of this.store.keywords) {
-      if (normalized.includes(keyword.term.toLowerCase())) {
-        const tp = keyword.truePositiveCount ?? 0;
-        const fp = keyword.falsePositiveCount ?? 0;
-        const accuracy = (tp + fp) > 0 ? tp / (tp + fp) : 1;
-        const score = keyword.weight * accuracy;
-
-        totalScore += score;
-        matchedTerms.push(keyword.term);
-      }
-    }
-
-    const cappedScore = Math.min(1, totalScore);
-    const isMatched = matchedTerms.length > 0;
-
-    const termConfidence = Math.min(1, matchedTerms.length / 3);
-    const scoreConfidence = Math.min(1, cappedScore / 0.8);
-    const confidence = Math.max(termConfidence, scoreConfidence);
-
-    return {
-      matched: isMatched,
-      matchedTerms: matchedTerms.slice(0, 5),
-      score: cappedScore,
-      confidence,
-    };
-  }
-
-  recordHits(terms: string[]): void {
-    for (const term of terms) {
-      const keywordIndex = this.store.keywords.findIndex(k => k.term.toLowerCase() === term.toLowerCase());
-      if (keywordIndex < 0) continue;
-      const keyword = this.store.keywords[keywordIndex];
-      this.store.keywords[keywordIndex] = {
-        ...keyword,
-        hitCount: (keyword.hitCount ?? 0) + 1,
-        lastHitAt: new Date().toISOString(),
-      };
-    }
-  }
-
-  recordTruePositive(term: string): void {
-    const keyword = this.store.keywords.find(k => k.term.toLowerCase() === term.toLowerCase());
-    if (!keyword) return;
-
-    keyword.truePositiveCount = (keyword.truePositiveCount ?? 0) + 1;
-
-    const keywordIndex = this.store.keywords.findIndex(k => k.term.toLowerCase() === term.toLowerCase());
-    if (keywordIndex >= 0) {
-      this.store.keywords[keywordIndex] = { ...keyword };
-    }
-
-    this.flush();
-  }
-
-  recordFalsePositive(term: string): void {
-    const keyword = this.store.keywords.find(k => k.term.toLowerCase() === term.toLowerCase());
-    if (!keyword) return;
-
-    keyword.falsePositiveCount = (keyword.falsePositiveCount ?? 0) + 1;
-
-    keyword.weight = Math.max(MIN_KEYWORD_WEIGHT, keyword.weight * 0.8);
-    keyword.lastHitAt = new Date().toISOString();
-
-    const keywordIndex = this.store.keywords.findIndex(k => k.term.toLowerCase() === term.toLowerCase());
-    if (keywordIndex >= 0) {
-      this.store.keywords[keywordIndex] = { ...keyword };
-    }
-
-    this.flush();
-  }
-
-  add(keyword: Omit<CorrectionKeyword, 'addedAt'>): void {
-    if (this.store.keywords.length >= MAX_CORRECTION_KEYWORDS) {
-      throw new Error('Correction keyword store limit reached (200 terms)');
-    }
-
-    const entry: CorrectionKeyword = {
-      ...keyword,
-      addedAt: new Date().toISOString(),
-    };
-
-    this.store.keywords.push(entry);
-    this.flush();
-  }
-
-  updateWeight(term: string, weight: number): void {
-    const keyword = this.store.keywords.find(
-      k => k.term.toLowerCase() === term.toLowerCase()
-    );
-    if (!keyword) {
-      throw new Error(`Keyword not found: ${term}`);
-    }
-
-    keyword.weight = Math.max(MIN_KEYWORD_WEIGHT, Math.min(MAX_KEYWORD_WEIGHT, weight));
-    const idx = this.store.keywords.findIndex(
-      k => k.term.toLowerCase() === term.toLowerCase()
-    );
-    if (idx >= 0) {
-      this.store.keywords[idx] = { ...keyword };
-    }
-    this.flush();
-  }
-
-  remove(term: string): void {
-    const idx = this.store.keywords.findIndex(
-      k => k.term.toLowerCase() === term.toLowerCase()
-    );
-    if (idx < 0) {
-      throw new Error(`Keyword not found: ${term}`);
-    }
-    this.store.keywords.splice(idx, 1);
-    this.flush();
-  }
-
-  getStore(): CorrectionKeywordStore {
-    return this.store;
-  }
-
-  getLastOptimizedAt(): string {
-    return this.store.lastOptimizedAt;
-  }
-
-  flush(): void {
-    saveCorrectionKeywordStore(this.stateDir, this.store);
-  }
-
-  static get(stateDir: string): CorrectionCueLearner {
-    if (!_instance || _lastStateDir !== stateDir) {
-      _instance = new CorrectionCueLearner(stateDir);
-      _lastStateDir = stateDir;
-    }
-    return _instance;
-  }
-}

package/src/core/correction-types.ts

@@ -1,16 +0,0 @@
-import type {
-  CorrectionKeyword,
-  CorrectionKeywordStore,
-  CorrectionMatchResult,
-} from '@principles/core/runtime-v2';
-
-export type {
-  CorrectionKeyword,
-  CorrectionKeywordStore,
-  CorrectionMatchResult,
-};
-
-export {
-  MAX_CORRECTION_KEYWORDS,
-  CORRECTION_SEED_KEYWORDS,
-} from '@principles/core/runtime-v2';