create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/runtime-v2-prompt-activation-reader.js

@@ -1,99 +0,0 @@
-import { SqliteConnection, SqliteActivationStateStore, computeFeatureFlagsFromConfig, filterPromptActivations, resolvePrincipleFromArtifact } from '@principles/core/runtime-v2';
-import { loadPdConfigForPlugin } from './pd-config-loader.js';
-export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
-export class PromptActivationReader {
-    workspaceDir;
-    deps;
-    constructor(workspaceDir, deps) {
-        this.workspaceDir = workspaceDir;
-        this.deps = deps ?? {};
-    }
-    async readActivatedPrinciples() {
-        const warnings = [];
-        const principles = [];
-        const flags = this.loadFeatureFlags();
-        const promptFlag = flags.flags['prompt'];
-        if (!promptFlag || !promptFlag.enabled) {
-            this.deps.logger?.info?.(`[PD:RuntimeV2] Prompt feature flag disabled — skipping Runtime V2 activation read`);
-            return { principles, warnings: ['prompt_feature_disabled'], source: 'runtime_v2' };
-        }
-        let sqliteConn = null;
-        try {
-            sqliteConn = new SqliteConnection(this.workspaceDir);
-            const store = new SqliteActivationStateStore(sqliteConn);
-            const allActivations = await store.listPromptActivations();
-            const promptActivations = filterPromptActivations(allActivations);
-            for (const activation of promptActivations) {
-                let artifactRow;
-                try {
-                    artifactRow = this.queryArtifactRow(sqliteConn, activation.artifactId);
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    const warning = `artifact_query_failed: artifactId=${activation.artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`;
-                    warnings.push(warning);
-                    this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
-                    continue;
-                }
-                if (artifactRow === null) {
-                    const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table_or_remove_stale_activation`;
-                    warnings.push(warning);
-                    this.deps.logger?.info?.(`[PD:RuntimeV2] ${warning}`);
-                    continue;
-                }
-                const result = resolvePrincipleFromArtifact(artifactRow, activation);
-                if (result.ok) {
-                    principles.push(result.principle);
-                }
-                else {
-                    warnings.push(result.warning);
-                    this.deps.logger?.warn?.(`[PD:RuntimeV2] ${result.warning}`);
-                }
-            }
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            const warning = `activation_db_unreadable: ${msg}; nextAction=check_workspace_pd_state_db`;
-            warnings.push(warning);
-            this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
-        }
-        finally {
-            try {
-                sqliteConn?.close();
-            }
-            catch {
-                // best-effort
-            }
-        }
-        return { principles, warnings, source: 'runtime_v2' };
-    }
-    queryArtifactRow(sqliteConn, artifactId) {
-        try {
-            const db = sqliteConn.getDb();
-            const row = db.prepare(`
-        SELECT artifact_id, artifact_kind, content_json, validation_status
-        FROM pi_artifacts
-        WHERE artifact_id = ?
-      `).get(artifactId);
-            return row ?? null;
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            throw new Error(`artifact_query_failed: artifactId=${artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`);
-        }
-    }
-    /**
-     * PRI-305/PRI-307: Load feature flags from .pd/config.yaml instead of .pd/feature-flags.yaml.
-     * Uses the shared plugin config loader for consistency.
-     */
-    loadFeatureFlags() {
-        const result = loadPdConfigForPlugin(this.workspaceDir);
-        const flags = computeFeatureFlagsFromConfig(result.effective);
-        if (!result.ok) {
-            for (const err of result.errors) {
-                this.deps.logger?.warn?.(`[PD:RuntimeV2] Config error at ${err.path}: ${err.reason}`);
-            }
-        }
-        return flags;
-    }
-}

package/plugin/dist/core/session-tracker.js

@@ -1,462 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { atomicWriteFileSync } from '../utils/io.js';
-import { SystemLogger } from './system-logger.js';
-import { TWO_HOURS_MS } from '../config/defaults/runtime.js';
-import { applyFriction as coreApplyFriction, applyDecay as coreApplyDecay, applyRelief as coreApplyRelief, classifyGfiStage, DEFAULT_GFI_POLICY, } from '@principles/core/runtime-v2';
-// ── GFI Core Kernel Adapter ──────────────────────────────────────────────────
-/** Convert SessionState GFI fields to GfiState for core kernel */
-function toGfiState(state) {
-    return {
-        currentGfi: state.currentGfi ?? 0,
-        gfiBySource: (state.gfiBySource ?? {}),
-        lastErrorHash: state.lastErrorHash === '' ? undefined : state.lastErrorHash,
-        lastErrorSource: state.lastErrorSource || undefined,
-        consecutiveErrors: state.consecutiveErrors ?? 0,
-        lastGfiDecayAt: state.lastGfiDecayAt,
-        dailyGfiPeak: state.dailyGfiPeak,
-    };
-}
-/** Apply GfiState result back onto SessionState */
-function applyGfiResult(state, result) {
-    state.currentGfi = result.currentGfi;
-    state.gfiBySource = { ...result.gfiBySource };
-    state.lastErrorHash = result.lastErrorHash ?? '';
-    state.lastErrorSource = result.lastErrorSource ?? '';
-    state.consecutiveErrors = result.consecutiveErrors;
-    state.lastGfiDecayAt = result.lastGfiDecayAt;
-    state.dailyGfiPeak = result.dailyGfiPeak ?? state.dailyGfiPeak;
-}
-const sessions = new Map();
-/** Directory for persisting session state */
-let persistDir = null;
-/** Debounce timers for persistence, one per session */
-const persistTimers = new Map();
-function logSessionTrackerWarning(message, error) {
-    const detail = error instanceof Error ? error.message : error ? String(error) : '';
-    const suffix = detail ? `: ${detail}` : '';
-    console.warn(`[PD:SessionTracker] ${message}${suffix}`);
-}
-function touchActivity(state, kind = 'general') {
-    const now = Date.now();
-    state.lastActivityAt = now;
-    if (kind === 'control') {
-        state.lastControlActivityAt = now;
-    }
-}
-/**
- * Initialize persistence for session state.
- * Call this once during plugin startup.
- */
-export function initPersistence(stateDir) {
-    persistDir = path.join(stateDir, 'sessions');
-    if (!fs.existsSync(persistDir)) {
-        fs.mkdirSync(persistDir, { recursive: true });
-    }
-    // Load all existing sessions
-    loadAllSessions();
-}
-/**
- * Get the file path for a session's persisted state.
- */
-function getSessionPath(sessionId) {
-    if (!persistDir)
-        return '';
-    // Sanitize sessionId for filesystem
-    const safeId = sessionId.replace(/[/\\:]/g, '_');
-    return path.join(persistDir, `${safeId}.json`);
-}
-/**
- * Load all persisted sessions from disk.
- */
-function loadAllSessions() {
-    if (!persistDir || !fs.existsSync(persistDir))
-        return;
-    try {
-        const files = fs.readdirSync(persistDir).filter(f => f.endsWith('.json'));
-        const now = Date.now();
-        const twoHoursAgo = now - TWO_HOURS_MS;
-        for (const file of files) {
-            try {
-                const content = fs.readFileSync(path.join(persistDir, file), 'utf-8');
-                const state = JSON.parse(content);
-                // Skip abandoned sessions
-                if (state.lastActivityAt < twoHoursAgo) {
-                    continue;
-                }
-                sessions.set(state.sessionId, state);
-            }
-            catch (error) {
-                logSessionTrackerWarning(`Failed to load session snapshot ${file}`, error);
-            }
-        }
-    }
-    catch (err) {
-        logSessionTrackerWarning('Failed to load persisted sessions', err);
-    }
-}
-/**
- * Persist a single session to disk.
- */
-function persistSession(state) {
-    if (!persistDir)
-        return;
-    const sessionPath = getSessionPath(state.sessionId);
-    if (!sessionPath)
-        return;
-    try {
-        atomicWriteFileSync(sessionPath, JSON.stringify(state, null, 2));
-        // Log successful persistence with GFI snapshot for debugging
-        if (state.currentGfi > 0) {
-            SystemLogger.log(state.workspaceDir, 'GFI_PERSIST', `Session ${state.sessionId.slice(0, 8)} persisted: GFI=${state.currentGfi.toFixed(1)}, sources=${JSON.stringify(state.gfiBySource)}`);
-        }
-    }
-    catch (error) {
-        logSessionTrackerWarning(`Failed to persist session ${state.sessionId}`, error);
-    }
-}
-/**
- * Schedule persistence with debounce.
- */
-function schedulePersistence(state) {
-    const existing = persistTimers.get(state.sessionId);
-    if (existing) {
-        clearTimeout(existing);
-    }
-    const timer = setTimeout(() => {
-        persistSession(state);
-        persistTimers.delete(state.sessionId);
-    }, 1000); // 1 second debounce
-    timer.unref(); // Don't keep process alive for persistence
-    persistTimers.set(state.sessionId, timer);
-}
-/**
- * Force persist all sessions immediately.
- */
-export function flushAllSessions() {
-    for (const timer of persistTimers.values()) {
-        clearTimeout(timer);
-    }
-    persistTimers.clear();
-    for (const state of sessions.values()) {
-        persistSession(state);
-    }
-}
-function getOrCreateSession(sessionId, workspaceDir, sessionKey, trigger) {
-    let state = sessions.get(sessionId);
-    if (!state) {
-        state = {
-            sessionId,
-            sessionKey,
-            trigger,
-            workspaceDir,
-            toolReadsByFile: {},
-            llmTurns: 0,
-            blockedAttempts: 0,
-            lastActivityAt: Date.now(),
-            lastControlActivityAt: Date.now(),
-            totalInputTokens: 0,
-            totalOutputTokens: 0,
-            cacheHits: 0,
-            stuckLoops: 0,
-            currentGfi: 0,
-            gfiBySource: {},
-            lastErrorSource: '',
-            lastErrorHash: '',
-            consecutiveErrors: 0,
-            lastGfiDecayAt: Date.now(),
-            dailyToolCalls: 0,
-            dailyToolFailures: 0,
-            dailyPainSignals: 0,
-            dailyGfiPeak: 0,
-            lastThinkingTimestamp: 0,
-            injectedProbationIds: [],
-        };
-        sessions.set(sessionId, state);
-    }
-    if (workspaceDir && !state.workspaceDir) {
-        state.workspaceDir = workspaceDir;
-    }
-    // Update sessionKey and trigger if provided (they may be more recent)
-    if (sessionKey && !state.sessionKey) {
-        state.sessionKey = sessionKey;
-    }
-    if (trigger && !state.trigger) {
-        state.trigger = trigger;
-    }
-    return state;
-}
-export function trackToolRead(sessionId, filePath, workspaceDir) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    const normalizedPath = path.posix.normalize(filePath.replace(/\\/g, '/'));
-    state.toolReadsByFile[normalizedPath] = (state.toolReadsByFile[normalizedPath] || 0) + 1;
-    touchActivity(state);
-    return state;
-}
-export function trackLlmOutput(sessionId, usage, config, workspaceDir, sessionKey, trigger) {
-    const state = getOrCreateSession(sessionId, workspaceDir, sessionKey, trigger);
-    state.llmTurns += 1;
-    touchActivity(state);
-    if (usage) {
-        state.totalInputTokens += usage.input || 0;
-        state.totalOutputTokens += usage.output || 0;
-        state.cacheHits += usage.cacheRead || 0;
-        // Use thresholds from config or defaults
-        const minTurns = 5; // Increased from 3 to 5 to prevent false positives on short tasks
-        const outputThreshold = 30; // Decreased from 50. Only penalize truly stunted outputs.
-        const inputThreshold = config ? config.get('thresholds.cognitive_paralysis_input') : 8000; // Increased base to 8k
-        // Very rough heuristic for empty/paralysis loops: high input context, tiny output, multiple turns
-        if (state.llmTurns > minTurns) {
-            const isTinyOutput = (usage.output || 0) < outputThreshold;
-            const isLargeInput = (usage.input || 0) > inputThreshold;
-            if (isTinyOutput && isLargeInput) {
-                state.stuckLoops += 1;
-                SystemLogger.log(state.workspaceDir, 'EFFICIENCY_ALARM', `Stuck loop detected (Turn ${state.llmTurns}). Input: ${usage.input}, Output: ${usage.output}. Consecutive: ${state.stuckLoops}`);
-            }
-            else {
-                // Reset if we broke out of the tiny output loop
-                if (state.stuckLoops > 0) {
-                    SystemLogger.log(state.workspaceDir, 'EFFICIENCY_OK', `Broke out of stuck loop after ${state.stuckLoops} turns.`);
-                }
-                state.stuckLoops = Math.max(0, state.stuckLoops - 1);
-            }
-        }
-    }
-    return state;
-}
-/**
- * Tracks physical friction based on tool execution failures.
- * Delegates to core GFI kernel for scoring.
- */
-export function trackFriction(sessionId, deltaF, hash, workspaceDir, options) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    const source = options?.source ?? 'unknown';
-    const event = {
-        source,
-        baseScore: deltaF,
-        hash: hash || undefined,
-    };
-    const coreState = toGfiState(state);
-    const nextCore = coreApplyFriction(coreState, event, DEFAULT_GFI_POLICY);
-    // Preserve composite source key for unattributed sources
-    if (!options?.source && hash) {
-        const val = nextCore.gfiBySource['unknown'];
-        if (val !== undefined) {
-            const s = nextCore.gfiBySource;
-            delete s['unknown'];
-            const key = `unattributed:${hash}`;
-            s[key] = (s[key] ?? 0) + val;
-        }
-    }
-    applyGfiResult(state, nextCore);
-    touchActivity(state, 'control');
-    // Update daily stats
-    state.dailyToolFailures++;
-    state.dailyGfiPeak = Math.max(state.dailyGfiPeak, state.currentGfi);
-    // Schedule persistence
-    state.lastGfiDecayAt = Date.now();
-    schedulePersistence(state);
-    return state;
-}
-/**
- * Resets the friction index upon successful action.
- * Delegates to core GFI kernel for relief computation.
- */
-export function resetFriction(sessionId, workspaceDir, options) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    if (options?.source) {
-        const coreState = toGfiState(state);
-        const nextCore = coreApplyRelief(coreState, { source: options.source, amount: options.amount ?? 0 }, Date.now(), DEFAULT_GFI_POLICY);
-        applyGfiResult(state, nextCore);
-        if (state.currentGfi > 0) {
-            SystemLogger.log(state.workspaceDir, 'GFI_SLICE_RESET', `Friction slice reset for ${options.source}: remaining GFI=${state.currentGfi.toFixed(1)}`);
-        }
-        touchActivity(state, 'control');
-        schedulePersistence(state);
-        return state;
-    }
-    // Full reset via core kernel
-    const previousGfi = state.currentGfi;
-    const coreState = toGfiState(state);
-    const nextCore = coreApplyRelief(coreState, { source: 'all', amount: 100 }, Date.now(), DEFAULT_GFI_POLICY);
-    applyGfiResult(state, nextCore);
-    if (previousGfi > 0) {
-        SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${previousGfi.toFixed(1)}). Action successful.`);
-    }
-    touchActivity(state, 'control');
-    schedulePersistence(state);
-    return state;
-}
-/**
- * Records that deep thinking (Thinking OS) was performed in this session.
- * Used by the Thinking OS checkpoint to allow high-risk operations.
- */
-export function recordThinkingCheckpoint(sessionId, workspaceDir) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    state.lastThinkingTimestamp = Date.now();
-    touchActivity(state, 'control');
-    SystemLogger.log(state.workspaceDir, 'THINKING_CHECKPOINT', `Deep thinking recorded at ${new Date(state.lastThinkingTimestamp).toISOString()}`);
-    schedulePersistence(state);
-    return state;
-}
-/**
- * Checks if deep thinking was performed recently (within the given window).
- * @param sessionId - The session to check
- * @param windowMs - How recent the thinking must be (default: 5 minutes)
- * @returns true if thinking was recorded within the window
- */
-export function hasRecentThinking(sessionId, windowMs = 5 * 60 * 1000) {
-    const state = sessions.get(sessionId);
-    if (!state || !state.lastThinkingTimestamp)
-        return false;
-    return (Date.now() - state.lastThinkingTimestamp) < windowMs;
-}
-export function trackBlock(sessionId) {
-    const state = getOrCreateSession(sessionId);
-    state.blockedAttempts += 1;
-    touchActivity(state, 'control');
-    schedulePersistence(state);
-    return state;
-}
-export function setInjectedProbationIds(sessionId, ids, workspaceDir) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    state.injectedProbationIds = [...ids];
-    touchActivity(state, 'control');
-    schedulePersistence(state);
-    return state;
-}
-export function getInjectedProbationIds(sessionId, workspaceDir) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    return [...(state.injectedProbationIds || [])];
-}
-export function clearInjectedProbationIds(sessionId, workspaceDir) {
-    return setInjectedProbationIds(sessionId, [], workspaceDir);
-}
-export function getSession(sessionId) {
-    return sessions.get(sessionId);
-}
-export function listSessions(workspaceDir) {
-    return [...sessions.values()]
-        .filter((state) => !workspaceDir || !state.workspaceDir || state.workspaceDir === workspaceDir)
-        .map((state) => ({
-        ...state,
-        toolReadsByFile: { ...state.toolReadsByFile },
-        gfiBySource: state.gfiBySource ? { ...state.gfiBySource } : undefined,
-        injectedProbationIds: state.injectedProbationIds ? [...state.injectedProbationIds] : undefined,
-    }));
-}
-export function clearSession(sessionId) {
-    const timer = persistTimers.get(sessionId);
-    if (timer) {
-        clearTimeout(timer);
-        persistTimers.delete(sessionId);
-    }
-    sessions.delete(sessionId);
-}
-/**
- * Seed a session directly into SessionTracker.sessions for testing.
- * This bypasses the normal tool-call flow to set up test data for
- * checkWorkspaceIdle without requiring full integration test setup.
- *
- * @param sessionId - Session ID
- * @param workspaceDir - Workspace directory (optional, for filtering)
- * @param lastActivityAt - Unix timestamp in ms (default: now)
- */
-export function seedSessionForTest(sessionId, workspaceDir, lastActivityAt) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
-    state.lastActivityAt = lastActivityAt ?? Date.now();
-    state.lastControlActivityAt = state.lastActivityAt;
-}
-// Memory cleanup for abandoned sessions (older than 2 hours)
-export function garbageCollectSessions() {
-    const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
-    for (const [id, state] of sessions.entries()) {
-        if (state.lastActivityAt < twoHoursAgo) {
-            const timer = persistTimers.get(id);
-            if (timer) {
-                clearTimeout(timer);
-                persistTimers.delete(id);
-            }
-            sessions.delete(id);
-            // Also delete persisted file
-            if (persistDir) {
-                const sessionPath = getSessionPath(id);
-                if (sessionPath && fs.existsSync(sessionPath)) {
-                    try {
-                        fs.unlinkSync(sessionPath);
-                    }
-                    catch (error) {
-                        logSessionTrackerWarning(`Failed to delete session snapshot for ${id}`, error);
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * Get daily statistics summary for a session.
- */
-export function getDailySummary(sessionId) {
-    const state = sessions.get(sessionId);
-    if (!state)
-        return null;
-    return {
-        toolCalls: state.dailyToolCalls,
-        toolFailures: state.dailyToolFailures,
-        painSignals: state.dailyPainSignals,
-        gfiPeak: state.dailyGfiPeak,
-    };
-}
-/**
- * Reset daily statistics (call at midnight or on new day).
- */
-export function resetDailyStats(sessionId) {
-    const state = sessions.get(sessionId);
-    if (state) {
-        state.dailyToolCalls = 0;
-        state.dailyToolFailures = 0;
-        state.dailyPainSignals = 0;
-        state.dailyGfiPeak = 0;
-        schedulePersistence(state);
-    }
-}
-/**
- * Apply time-based decay to GFI using stage-aware linear decay.
- * Delegates to core GFI kernel.
- *
- * @param sessionId - The session to decay
- * @param elapsedMinutes - Minutes since last decay
- * @returns Updated session state, or undefined if session not found or GFI is 0
- */
-export function decayGfi(sessionId, elapsedMinutes) {
-    const state = sessions.get(sessionId);
-    if (!state || state.currentGfi <= 0 || elapsedMinutes <= 0)
-        return undefined;
-    const coreState = toGfiState(state);
-    const stage = classifyGfiStage(state.currentGfi, DEFAULT_GFI_POLICY);
-    const nextCore = coreApplyDecay(coreState, elapsedMinutes, DEFAULT_GFI_POLICY, stage, Date.now());
-    const previousGfi = state.currentGfi;
-    applyGfiResult(state, nextCore);
-    // Log if significant decay
-    const decayedAmount = previousGfi - state.currentGfi;
-    if (decayedAmount >= 1) {
-        SystemLogger.log(state.workspaceDir, 'GFI_DECAY', `GFI decayed by ${decayedAmount.toFixed(1)} (${elapsedMinutes}min). ${previousGfi.toFixed(1)} → ${state.currentGfi.toFixed(1)}`);
-    }
-    schedulePersistence(state);
-    return state;
-}
-/**
- * Check if GFI decay should be applied and return elapsed minutes since last decay.
- * @param sessionId - The session to check
- * @returns Elapsed minutes since last decay, or 0 if no decay needed
- */
-export function getGfiDecayElapsed(sessionId) {
-    const state = sessions.get(sessionId);
-    if (!state || state.currentGfi <= 0)
-        return 0;
-    const now = Date.now();
-    const lastDecay = state.lastGfiDecayAt || state.lastControlActivityAt || state.lastActivityAt || now;
-    const elapsedMs = now - lastDecay;
-    // Return elapsed minutes (floor to whole minutes)
-    return Math.floor(elapsedMs / 60000);
-}