principles-disciple 1.127.0 → 1.129.0

package/dist/core/control-ui-db.js

@@ -0,0 +1,309 @@
+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';
+const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+function safeJson(value) {
+    return JSON.stringify(value ?? []);
+}
+export class ControlUiDatabase {
+    workspaceDir;
+    dbPath;
+    blobDir;
+    db;
+    constructor(opts) {
+        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() {
+        this.db.close();
+    }
+    recordThinkingModelEvent(input) {
+        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, beforeCreatedAt, limit = 5) {
+        return {
+            toolCalls: this.all(`
+          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(`
+          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(`
+          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(`
+          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(`
+          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(sql, ...params) {
+        return this.db.prepare(sql).all(...params);
+    }
+    /**
+     * 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(sql, ...params) {
+        return this.db.prepare(sql).get(...params);
+    }
+    /**
+     * 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) {
+        this.db.exec(sql);
+    }
+    /**
+     * Execute a parameterized write statement (INSERT, UPDATE, DELETE).
+     */
+    run(sql, ...params) {
+        this.withWrite(() => {
+            this.db.prepare(sql).run(...params);
+        });
+    }
+    restoreRawText(inlineText, blobRef) {
+        if (inlineText)
+            return inlineText;
+        if (!blobRef)
+            return '';
+        const fullPath = path.join(this.blobDir, blobRef);
+        return fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : '';
+    }
+    initSchema() {
+        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;
+    `);
+    }
+    withWrite(fn) {
+        return withLock(this.dbPath, fn, { lockSuffix: '.trajectory.lock', lockStaleMs: 30000 });
+    }
+}

package/dist/core/correction-cue-learner.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 type { CorrectionKeyword, CorrectionKeywordStore, CorrectionMatchResult } from './correction-types.js';
+export declare function _resetCorrectionCueCache(): void;
+export declare function loadCorrectionKeywordStore(stateDir: string): CorrectionKeywordStore;
+export declare function saveCorrectionKeywordStore(stateDir: string, store: CorrectionKeywordStore): void;
+export declare function _resetCorrectionCueLearnerInstance(): void;
+export declare class CorrectionCueLearner {
+    private readonly store;
+    private readonly stateDir;
+    constructor(stateDir: string);
+    match(text: string): CorrectionMatchResult;
+    recordHits(terms: string[]): void;
+    recordTruePositive(term: string): void;
+    recordFalsePositive(term: string): void;
+    add(keyword: Omit<CorrectionKeyword, 'addedAt'>): void;
+    updateWeight(term: string, weight: number): void;
+    remove(term: string): void;
+    getStore(): CorrectionKeywordStore;
+    getLastOptimizedAt(): string;
+    flush(): void;
+    static get(stateDir: string): CorrectionCueLearner;
+}

package/dist/core/correction-cue-learner.js

@@ -0,0 +1,184 @@
+/**
+ * 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 { 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 = null;
+export function _resetCorrectionCueCache() {
+    _correctionCueCache = null;
+}
+function createDefaultStore() {
+    const now = new Date().toISOString();
+    const keywords = CORRECTION_SEED_KEYWORDS.map((k) => ({
+        ...k,
+        source: 'seed',
+        addedAt: now,
+    }));
+    return { keywords, version: 1, lastOptimizedAt: now };
+}
+export function loadCorrectionKeywordStore(stateDir) {
+    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);
+            return _correctionCueCache;
+        }
+        catch {
+            void 0;
+        }
+    }
+    const defaultStore = createDefaultStore();
+    saveCorrectionKeywordStore(stateDir, defaultStore);
+    _correctionCueCache = defaultStore;
+    return _correctionCueCache;
+}
+export function saveCorrectionKeywordStore(stateDir, store) {
+    const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
+    fs.mkdirSync(stateDir, { recursive: true });
+    atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
+    _correctionCueCache = null;
+}
+let _instance = null;
+let _lastStateDir = null;
+export function _resetCorrectionCueLearnerInstance() {
+    _instance = null;
+    _lastStateDir = null;
+}
+export class CorrectionCueLearner {
+    store;
+    stateDir;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+        this.store = loadCorrectionKeywordStore(stateDir);
+    }
+    match(text) {
+        const normalized = text
+            .trim()
+            .toLowerCase()
+            .replace(/[.,!?;:，。！？；：]/g, '');
+        const matchedTerms = [];
+        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) {
+        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) {
+        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) {
+        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) {
+        if (this.store.keywords.length >= MAX_CORRECTION_KEYWORDS) {
+            throw new Error('Correction keyword store limit reached (200 terms)');
+        }
+        const entry = {
+            ...keyword,
+            addedAt: new Date().toISOString(),
+        };
+        this.store.keywords.push(entry);
+        this.flush();
+    }
+    updateWeight(term, weight) {
+        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) {
+        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() {
+        return this.store;
+    }
+    getLastOptimizedAt() {
+        return this.store.lastOptimizedAt;
+    }
+    flush() {
+        saveCorrectionKeywordStore(this.stateDir, this.store);
+    }
+    static get(stateDir) {
+        if (!_instance || _lastStateDir !== stateDir) {
+            _instance = new CorrectionCueLearner(stateDir);
+            _lastStateDir = stateDir;
+        }
+        return _instance;
+    }
+}

package/dist/core/correction-types.d.ts

@@ -0,0 +1,3 @@
+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';

package/dist/core/correction-types.js

@@ -0,0 +1 @@
+export { MAX_CORRECTION_KEYWORDS, CORRECTION_SEED_KEYWORDS, } from '@principles/core/runtime-v2';

package/dist/core/detection-funnel.d.ts

@@ -0,0 +1,33 @@
+import { type PainDictionary } from './dictionary.js';
+export interface DetectionResult {
+    detected: boolean;
+    severity?: number;
+    ruleId?: string;
+    source: 'l1_exact' | 'l2_cache' | 'l3_async_queued' | 'l3_semantic_hit';
+}
+/**
+ * Orchestrates the three-layer detection funnel for pain signals.
+ */
+export declare class DetectionFunnel {
+    private readonly cache;
+    private asyncQueue;
+    private readonly dictionary;
+    constructor(dictionary: PainDictionary);
+    /**
+     * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
+     */
+    detect(text: string): DetectionResult;
+    private static computeHash;
+    private enqueueAsync;
+    /**
+     * Internal method for the worker to update the cache after a semantic hit.
+     */
+    updateCache(text: string, result: {
+        detected: boolean;
+        severity?: number;
+    }): void;
+    /**
+     * Retrieves and clears the current asynchronous queue.
+     */
+    flushQueue(): string[];
+}

package/{src/core/detection-funnel.ts → dist/core/detection-funnel.js}

@@ -1,25 +1,16 @@
 import { createHash } from 'crypto';
-import { shouldIgnorePainProtocolText, type PainDictionary } from './dictionary.js';
-
-export interface DetectionResult {
-    detected: boolean;
-    severity?: number;
-    ruleId?: string;
-    source: 'l1_exact' | 'l2_cache' | 'l3_async_queued' | 'l3_semantic_hit';
-}
-
+import { shouldIgnorePainProtocolText } from './dictionary.js';
 /**
  * A simple LRU Cache implementation using Map.
  */
-class SimpleLRU<K, V> {
-    private readonly cache: Map<K, V>;
-    private readonly maxSize: number;
+class SimpleLRU {
+    cache;
+    maxSize;
     constructor(maxSize = 100) {
         this.cache = new Map();
         this.maxSize = maxSize;
     }
-
-    get(key: K): V | undefined {
+    get(key) {
         const item = this.cache.get(key);
         if (item !== undefined) {
             // Refresh: delete and re-insert
@@ -28,11 +19,11 @@ class SimpleLRU<K, V> {
         }
         return item;
     }
-
-    set(key: K, value: V): void {
+    set(key, value) {
         if (this.cache.has(key)) {
             this.cache.delete(key);
-        } else if (this.cache.size >= this.maxSize) {
+        }
+        else if (this.cache.size >= this.maxSize) {
             // Remove the oldest (first) item
             const firstKey = this.cache.keys().next().value;
             if (firstKey !== undefined) {
@@ -42,27 +33,23 @@ class SimpleLRU<K, V> {
         this.cache.set(key, value);
     }
 }
-
 /**
  * Orchestrates the three-layer detection funnel for pain signals.
  */
 export class DetectionFunnel {
-    private readonly cache = new SimpleLRU<string, { detected: boolean; severity?: number }>(100);
-    private asyncQueue: string[] = [];
-    private readonly dictionary: PainDictionary;
-
-    constructor(dictionary: PainDictionary) {
+    cache = new SimpleLRU(100);
+    asyncQueue = [];
+    dictionary;
+    constructor(dictionary) {
         this.dictionary = dictionary;
     }
-
     /**
      * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
      */
-    detect(text: string): DetectionResult {
+    detect(text) {
         if (shouldIgnorePainProtocolText(text)) {
             return { detected: false, source: 'l1_exact' };
         }
-
         // --- Layer 1: Exact Match (Sync) ---
         const exactMatch = this.dictionary.match(text);
         if (exactMatch) {
@@ -73,7 +60,6 @@ export class DetectionFunnel {
                 source: 'l1_exact'
             };
         }
-
         // --- Layer 2: LRU Cache (Sync) ---
         const hash = DetectionFunnel.computeHash(text);
         const cached = this.cache.get(hash);
@@ -84,39 +70,33 @@ export class DetectionFunnel {
                 source: 'l2_cache'
             };
         }
-
         // --- Layer 3: Async Semantic Queue ---
         this.enqueueAsync(text);
-        
         return {
             detected: false,
             source: 'l3_async_queued'
         };
     }
-
-    private static computeHash(text: string): string {
+    static computeHash(text) {
         return createHash('sha256').update(text).digest('hex');
     }
-
-    private enqueueAsync(text: string): void {
+    enqueueAsync(text) {
         if (this.asyncQueue.length < 1000) {
             this.asyncQueue.push(text);
         }
         // Worker will pick this up and perform semantic search via createMemorySearchTool
     }
-
     /**
      * Internal method for the worker to update the cache after a semantic hit.
      */
-    updateCache(text: string, result: { detected: boolean; severity?: number }): void {
+    updateCache(text, result) {
         const hash = DetectionFunnel.computeHash(text);
         this.cache.set(hash, result);
     }
-
     /**
      * Retrieves and clears the current asynchronous queue.
      */
-    flushQueue(): string[] {
+    flushQueue() {
         const queue = [...this.asyncQueue];
         this.asyncQueue = [];
         return queue;