principles-disciple 1.5.4

package/dist/core/risk-calculator.js

@@ -0,0 +1,39 @@
+import { isRisky } from '../utils/io.js';
+export function estimateLineChanges(modification) {
+    const { toolName, params } = modification;
+    if (toolName === 'write_file' || toolName === 'write') {
+        const content = params.content || '';
+        return content.split('\n').length;
+    }
+    if (toolName === 'replace' || toolName === 'edit') {
+        const newContent = params.new_string || params.newText || '';
+        return newContent.split('\n').length;
+    }
+    if (toolName === 'apply_patch' || toolName === 'patch') {
+        const patch = params.patch || '';
+        // Rough estimate for patch files
+        return patch.split('\n').filter((l) => l.startsWith('+') || l.startsWith('-')).length;
+    }
+    if (toolName === 'delete_file') {
+        // Deleting a file is considered a significant change, but we don't know the size. 
+        // We'll treat it as a medium-to-large size change.
+        return 50;
+    }
+    return 0;
+}
+export function assessRiskLevel(filePath, modification, riskPaths) {
+    const isRiskPath = isRisky(filePath, riskPaths);
+    const estimatedLines = estimateLineChanges(modification);
+    if (isRiskPath) {
+        if (estimatedLines > 100)
+            return 'CRITICAL';
+        return 'HIGH';
+    }
+    else {
+        if (estimatedLines > 100)
+            return 'HIGH';
+        if (estimatedLines > 10)
+            return 'MEDIUM';
+        return 'LOW';
+    }
+}

package/dist/core/session-tracker.d.ts

@@ -0,0 +1,76 @@
+import { PainConfig } from './config.js';
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+}
+export interface SessionState {
+    sessionId: string;
+    workspaceDir?: string;
+    toolReadsByFile: Record<string, number>;
+    llmTurns: number;
+    blockedAttempts: number;
+    lastActivityAt: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    cacheHits: number;
+    stuckLoops: number;
+    currentGfi: number;
+    lastErrorHash: string;
+    consecutiveErrors: number;
+    dailyToolCalls: number;
+    dailyToolFailures: number;
+    dailyPainSignals: number;
+    dailyGfiPeak: number;
+    lastThinkingTimestamp: number;
+}
+/**
+ * Initialize persistence for session state.
+ * Call this once during plugin startup.
+ */
+export declare function initPersistence(stateDir: string): void;
+/**
+ * Force persist all sessions immediately.
+ */
+export declare function flushAllSessions(): void;
+export declare function trackToolRead(sessionId: string, filePath: string, workspaceDir?: string): SessionState;
+export declare function trackLlmOutput(sessionId: string, usage: TokenUsage | undefined, config?: PainConfig, workspaceDir?: string): SessionState;
+/**
+ * Tracks physical friction based on tool execution failures.
+ */
+export declare function trackFriction(sessionId: string, deltaF: number, hash: string, workspaceDir?: string): SessionState;
+/**
+ * Resets the friction index upon successful action.
+ */
+export declare function resetFriction(sessionId: string, workspaceDir?: string): SessionState;
+/**
+ * Records that deep thinking (Thinking OS) was performed in this session.
+ * Used by the Thinking OS checkpoint to allow high-risk operations.
+ */
+export declare function recordThinkingCheckpoint(sessionId: string, workspaceDir?: string): SessionState;
+/**
+ * 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 declare function hasRecentThinking(sessionId: string, windowMs?: number): boolean;
+export declare function trackBlock(sessionId: string): SessionState;
+export declare function getSession(sessionId: string): SessionState | undefined;
+export declare function clearSession(sessionId: string): void;
+export declare function garbageCollectSessions(): void;
+/**
+ * Get daily statistics summary for a session.
+ */
+export declare function getDailySummary(sessionId: string): {
+    toolCalls: number;
+    toolFailures: number;
+    painSignals: number;
+    gfiPeak: number;
+} | null;
+/**
+ * Reset daily statistics (call at midnight or on new day).
+ */
+export declare function resetDailyStats(sessionId: string): void;

package/dist/core/session-tracker.js

@@ -0,0 +1,286 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { SystemLogger } from './system-logger.js';
+const sessions = new Map();
+/** Directory for persisting session state */
+let persistDir = null;
+/** Debounce timer for persistence */
+let persistTimer = null;
+/**
+ * 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 - 2 * 60 * 60 * 1000;
+        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 {
+                // Ignore corrupted files
+            }
+        }
+    }
+    catch (err) {
+        // Ignore errors during load
+    }
+}
+/**
+ * Persist a single session to disk.
+ */
+function persistSession(state) {
+    if (!persistDir)
+        return;
+    const sessionPath = getSessionPath(state.sessionId);
+    if (!sessionPath)
+        return;
+    try {
+        fs.writeFileSync(sessionPath, JSON.stringify(state, null, 2), 'utf-8');
+    }
+    catch {
+        // Ignore persistence errors
+    }
+}
+/**
+ * Schedule persistence with debounce.
+ */
+function schedulePersistence(state) {
+    if (persistTimer) {
+        clearTimeout(persistTimer);
+    }
+    persistTimer = setTimeout(() => {
+        persistSession(state);
+        persistTimer = null;
+    }, 1000); // 1 second debounce
+}
+/**
+ * Force persist all sessions immediately.
+ */
+export function flushAllSessions() {
+    for (const state of sessions.values()) {
+        persistSession(state);
+    }
+}
+function getOrCreateSession(sessionId, workspaceDir) {
+    let state = sessions.get(sessionId);
+    if (!state) {
+        state = {
+            sessionId,
+            workspaceDir,
+            toolReadsByFile: {},
+            llmTurns: 0,
+            blockedAttempts: 0,
+            lastActivityAt: Date.now(),
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            cacheHits: 0,
+            stuckLoops: 0,
+            currentGfi: 0,
+            lastErrorHash: '',
+            consecutiveErrors: 0,
+            dailyToolCalls: 0,
+            dailyToolFailures: 0,
+            dailyPainSignals: 0,
+            dailyGfiPeak: 0,
+            lastThinkingTimestamp: 0,
+        };
+        sessions.set(sessionId, state);
+    }
+    if (workspaceDir && !state.workspaceDir) {
+        state.workspaceDir = workspaceDir;
+    }
+    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;
+    state.lastActivityAt = Date.now();
+    return state;
+}
+export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    state.llmTurns += 1;
+    state.lastActivityAt = Date.now();
+    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.
+ */
+export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    if (hash && hash === state.lastErrorHash) {
+        state.consecutiveErrors++;
+    }
+    else {
+        state.lastErrorHash = hash;
+        state.consecutiveErrors = 1;
+    }
+    // GFI formula with multiplier: GFI = GFI + (Delta_F * 1.5^(n-1))
+    const multiplier = Math.pow(1.5, state.consecutiveErrors - 1);
+    const addedFriction = deltaF * multiplier;
+    state.currentGfi = (state.currentGfi || 0) + addedFriction;
+    state.lastActivityAt = Date.now();
+    SystemLogger.log(state.workspaceDir, 'GFI_INC', `Friction added: +${addedFriction.toFixed(1)} (Base: ${deltaF}, Mult: ${multiplier.toFixed(2)}). Total GFI: ${state.currentGfi.toFixed(1)}`);
+    // Update daily stats
+    state.dailyToolFailures++;
+    state.dailyGfiPeak = Math.max(state.dailyGfiPeak, state.currentGfi);
+    // Schedule persistence
+    schedulePersistence(state);
+    return state;
+}
+/**
+ * Resets the friction index upon successful action.
+ */
+export function resetFriction(sessionId, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    if (state.currentGfi > 0) {
+        SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${state.currentGfi.toFixed(1)}). Action successful.`);
+    }
+    state.currentGfi = 0;
+    state.consecutiveErrors = 0;
+    state.lastErrorHash = '';
+    // Schedule persistence
+    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();
+    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;
+    state.lastActivityAt = Date.now();
+    return state;
+}
+export function getSession(sessionId) {
+    return sessions.get(sessionId);
+}
+export function clearSession(sessionId) {
+    sessions.delete(sessionId);
+}
+// 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) {
+            sessions.delete(id);
+            // Also delete persisted file
+            if (persistDir) {
+                const sessionPath = getSessionPath(id);
+                if (sessionPath && fs.existsSync(sessionPath)) {
+                    try {
+                        fs.unlinkSync(sessionPath);
+                    }
+                    catch {
+                        // Ignore deletion errors
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * 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);
+    }
+}

package/dist/core/system-logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * System Logger for Principles Disciple
+ * Writes critical evolutionary events to the project's memory/logs/SYSTEM.log
+ * Uses asynchronous writing to avoid blocking the Node.js event loop.
+ */
+export declare const SystemLogger: {
+    log(workspaceDir: string | undefined, eventType: string, message: string): void;
+};

package/dist/core/system-logger.js

@@ -0,0 +1,31 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolvePdPath } from './paths.js';
+/**
+ * System Logger for Principles Disciple
+ * Writes critical evolutionary events to the project's memory/logs/SYSTEM.log
+ * Uses asynchronous writing to avoid blocking the Node.js event loop.
+ */
+export const SystemLogger = {
+    log(workspaceDir, eventType, message) {
+        if (!workspaceDir)
+            return;
+        try {
+            const logFile = resolvePdPath(workspaceDir, 'SYSTEM_LOG');
+            const logDir = path.dirname(logFile);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            const timestamp = new Date().toISOString();
+            // Format: [YYYY-MM-DDTHH:mm:ss.sssZ] [EVENT_TYPE] Message
+            const logEntry = `[${timestamp}] [${eventType.padEnd(15)}] ${message}\n`;
+            // Use fire-and-forget async append to prevent blocking
+            fs.appendFile(logFile, logEntry, 'utf8', (err) => {
+                // Silently drop errors (e.g. disk full) to not crash the gateway
+            });
+        }
+        catch (e) {
+            // Silently fail if we can't setup the log
+        }
+    }
+};

package/dist/core/trust-engine.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Trust Engine V2.1 - Recalibrated for Action Classification
+ * Differentiates between Exploratory (safe) and Constructive (risky) actions.
+ */
+export interface TrustScorecard {
+    trust_score: number;
+    success_streak: number;
+    failure_streak: number;
+    exploratory_failure_streak: number;
+    grace_failures_remaining?: number;
+    last_updated: string;
+    cold_start_end?: string;
+    first_activity_at?: string;
+    history: Array<{
+        type: 'success' | 'failure' | 'penalty' | 'info';
+        delta: number;
+        reason: string;
+        timestamp: string;
+    }>;
+}
+export type TrustStage = 1 | 2 | 3 | 4;
+export declare const EXPLORATORY_TOOLS: string[];
+export declare const CONSTRUCTIVE_TOOLS: string[];
+export declare class TrustEngine {
+    private scorecard;
+    private workspaceDir;
+    private stateDir;
+    constructor(workspaceDir: string);
+    private get config();
+    private get trustSettings();
+    private loadScorecard;
+    private saveScorecard;
+    getScore(): number;
+    getScorecard(): TrustScorecard;
+    getStage(): TrustStage;
+    isColdStart(): boolean;
+    recordSuccess(reason: string, context?: {
+        sessionId?: string;
+        api?: any;
+        toolName?: string;
+    }, isSubagent?: boolean): void;
+    recordFailure(type: 'tool' | 'risky' | 'bypass', context: {
+        sessionId?: string;
+        api?: any;
+        toolName?: string;
+    }): void;
+    private updateScore;
+    resetTrust(newScore?: number): void;
+    getStatusSummary(): {
+        stage: TrustStage;
+        successRate: number;
+        isInColdStart: boolean;
+        graceRemaining: number;
+        currentStreak: {
+            type: string;
+            count: number;
+        };
+    };
+    private calculateSuccessRate;
+}
+export declare function recordSuccess(workspaceDir: string, reason: string, context?: {
+    sessionId?: string;
+    api?: any;
+    toolName?: string;
+}, isSubagent?: boolean): void;
+export declare function recordFailure(type: 'tool' | 'risky' | 'bypass', workspaceDir: string, ctx: {
+    sessionId?: string;
+    api?: any;
+    toolName?: string;
+}): void;
+export declare function getAgentScorecard(workspaceDir: string): TrustScorecard;
+export declare function getTrustStats(scorecard: TrustScorecard): {
+    stage: TrustStage;
+    successRate: any;
+    isInColdStart: boolean;
+    graceRemaining: number;
+    currentStreak: {
+        type: string;
+        count: number;
+    };
+};
+export declare function getTrustStatus(workspaceDir: string): {
+    stage: TrustStage;
+    successRate: number;
+    isInColdStart: boolean;
+    graceRemaining: number;
+    currentStreak: {
+        type: string;
+        count: number;
+    };
+};