principles-disciple 1.5.4

package/dist/core/agent-loader.js

@@ -0,0 +1,147 @@
+/**
+ * Agent Definition Loader
+ *
+ * Parses agent definitions from agents/*.md files.
+ * These definitions are used to construct extraSystemPrompt for subagent runs.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Parse markdown file with YAML frontmatter
+ */
+function parseMarkdown(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const frontmatter = {};
+    const frontmatterText = match[1];
+    const body = match[2];
+    // Simple YAML-like parsing
+    let currentKey = '';
+    let currentArray = null;
+    frontmatterText.split('\n').forEach(line => {
+        // Array item
+        if (line.match(/^\s*-\s+/)) {
+            if (currentArray !== null) {
+                const value = line.replace(/^\s*-\s+/, '').trim();
+                currentArray.push(value);
+            }
+            return;
+        }
+        // Key-value pair
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.slice(0, colonIndex).trim();
+            const value = line.slice(colonIndex + 1).trim();
+            if (value === '') {
+                // Start of array
+                currentKey = key;
+                currentArray = [];
+                frontmatter[key] = currentArray;
+            }
+            else {
+                // Simple value
+                currentKey = '';
+                currentArray = null;
+                frontmatter[key] = value;
+            }
+        }
+    });
+    return { frontmatter, body };
+}
+/**
+ * Resolve the agents directory path
+ * Handles both development and installed scenarios
+ */
+function resolveAgentsDir() {
+    // Try multiple locations
+    const possiblePaths = [
+        // Development: relative to dist/core/
+        path.resolve(__dirname, '../../agents'),
+        // Installed: relative to extension root
+        path.resolve(__dirname, '../agents'),
+        // Absolute fallback
+        path.resolve(process.cwd(), 'agents'),
+    ];
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    // Return default (may not exist)
+    return possiblePaths[0];
+}
+/**
+ * Load agent definition by name
+ *
+ * @param name - Agent name (e.g., 'explorer', 'diagnostician')
+ * @returns Agent definition or null if not found
+ */
+export function loadAgentDefinition(name) {
+    const agentsDir = resolveAgentsDir();
+    const mdPath = path.join(agentsDir, `${name}.md`);
+    if (!fs.existsSync(mdPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(mdPath, 'utf8');
+        const { frontmatter, body } = parseMarkdown(content);
+        // Extract tools as array (support both string and array formats)
+        let tools;
+        if (Array.isArray(frontmatter.tools)) {
+            tools = frontmatter.tools;
+        }
+        else if (typeof frontmatter.tools === 'string') {
+            tools = frontmatter.tools.split(',').map(s => s.trim()).filter(Boolean);
+        }
+        return {
+            name: frontmatter.name || name,
+            description: frontmatter.description || '',
+            systemPrompt: body.trim(),
+            tools,
+            model: frontmatter.model,
+            permissionMode: frontmatter.permissionMode,
+            skills: frontmatter.skills,
+        };
+    }
+    catch (err) {
+        console.error(`[AgentLoader] Failed to load agent ${name}:`, err);
+        return null;
+    }
+}
+/**
+ * List all available agents
+ *
+ * @returns Array of agent names
+ */
+export function listAvailableAgents() {
+    const agentsDir = resolveAgentsDir();
+    if (!fs.existsSync(agentsDir)) {
+        return [];
+    }
+    try {
+        const files = fs.readdirSync(agentsDir);
+        return files
+            .filter(f => f.endsWith('.md'))
+            .map(f => path.basename(f, '.md'));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load all agent definitions
+ *
+ * @returns Map of agent name to definition
+ */
+export function loadAllAgents() {
+    const agents = new Map();
+    for (const name of listAvailableAgents()) {
+        const def = loadAgentDefinition(name);
+        if (def) {
+            agents.set(name, def);
+        }
+    }
+    return agents;
+}

package/dist/core/config-service.d.ts

@@ -0,0 +1,15 @@
+import { PainConfig } from './config.js';
+/**
+ * Singleton service to manage the Pain Configuration.
+ */
+export declare const ConfigService: {
+    /**
+     * Gets or initializes the Pain Configuration instance.
+     * @param stateDir The directory where the settings JSON is stored.
+     */
+    get(stateDir: string): PainConfig;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/dist/core/config-service.js

@@ -0,0 +1,26 @@
+import { PainConfig } from './config.js';
+let config = null;
+let lastStateDir = null;
+/**
+ * Singleton service to manage the Pain Configuration.
+ */
+export const ConfigService = {
+    /**
+     * Gets or initializes the Pain Configuration instance.
+     * @param stateDir The directory where the settings JSON is stored.
+     */
+    get(stateDir) {
+        if (!config || lastStateDir !== stateDir) {
+            config = new PainConfig(stateDir);
+            config.load();
+            lastStateDir = stateDir;
+        }
+        return config;
+    },
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset() {
+        config = null;
+    }
+};

package/dist/core/config.d.ts

@@ -0,0 +1,103 @@
+export interface DeepReflectionSettings {
+    enabled: boolean;
+    mode: 'auto' | 'forced' | 'disabled';
+    force_checkpoint?: boolean;
+    checkpoint_message?: string;
+    auto_trigger_conditions?: {
+        min_tool_calls?: number;
+        error_rate_threshold?: number;
+        complexity_keywords?: string[];
+    };
+    default_model?: string;
+    default_depth?: number;
+    timeout_ms?: number;
+    modelsDir?: string;
+}
+export interface TrustSettings {
+    stages: {
+        stage_1_observer: number;
+        stage_2_editor: number;
+        stage_3_developer: number;
+    };
+    cold_start: {
+        initial_trust: number;
+        grace_failures: number;
+        cold_start_period_ms: number;
+    };
+    penalties: {
+        tool_failure_base: number;
+        risky_failure_base: number;
+        gate_bypass_attempt: number;
+        failure_streak_multiplier: number;
+        max_penalty: number;
+    };
+    rewards: {
+        success_base: number;
+        subagent_success: number;
+        tool_success_reward: number;
+        streak_bonus_threshold: number;
+        streak_bonus: number;
+        recovery_boost: number;
+        max_reward: number;
+    };
+    limits: {
+        stage_2_max_lines: number;
+        stage_3_max_lines: number;
+    };
+    history_limit?: number;
+}
+export interface PainSettings {
+    language: 'en' | 'zh';
+    thresholds: {
+        pain_trigger: number;
+        cognitive_paralysis_input: number;
+        stuck_loops_trigger: number;
+        semantic_min_score: number;
+        promotion_count_threshold: number;
+        promotion_similarity_threshold: number;
+    };
+    scores: {
+        paralysis: number;
+        default_confusion: number;
+        default_loop: number;
+        tool_failure_friction: number;
+        exit_code_penalty: number;
+        spiral_penalty: number;
+        missing_test_command_penalty: number;
+        subagent_error_penalty: number;
+        subagent_timeout_penalty: number;
+    };
+    severity_thresholds: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+    intervals: {
+        worker_poll_ms: number;
+        initial_delay_ms: number;
+        task_timeout_ms: number;
+    };
+    trust: TrustSettings;
+    deep_reflection?: DeepReflectionSettings;
+}
+export declare const DEFAULT_SETTINGS: PainSettings;
+export declare class PainConfig {
+    private settings;
+    private filePath;
+    constructor(stateDir: string);
+    load(): void;
+    save(): void;
+    private deepMerge;
+    /**
+     * Basic validation for critical settings
+     */
+    private validate;
+    /**
+     * Gets a value using dot notation (e.g. 'thresholds.pain_trigger')
+     */
+    get(keyPath: string): any;
+    /**
+     * Returns all settings as a plain object.
+     */
+    getAll(): PainSettings;
+}

package/dist/core/config.js

@@ -0,0 +1,186 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// ─────────────────────────────────────────────────────────────
+// 🚀 THE "IT JUST WORKS" DEFAULT SETTINGS 🚀
+// These defaults have been carefully tuned to ensure that a
+// new user installing this plugin for the first time will NOT
+// be constantly blocked by the security gate. The AI is given
+// a high initial trust score (Developer stage) and penalties
+// are forgiving, encouraging exploration rather than paralysis.
+// ─────────────────────────────────────────────────────────────
+export const DEFAULT_SETTINGS = {
+    language: 'zh', // Optimized for the primary user base
+    thresholds: {
+        pain_trigger: 40, // Increased tolerance before forcing a stop
+        cognitive_paralysis_input: 4000,
+        stuck_loops_trigger: 4, // Allow more retries before calling it a loop
+        semantic_min_score: 0.7,
+        promotion_count_threshold: 3,
+        promotion_similarity_threshold: 0.8
+    },
+    scores: {
+        paralysis: 30, // Reduced from 40
+        default_confusion: 30,
+        default_loop: 40,
+        tool_failure_friction: 15, // Reduced from 30. A failing tool shouldn't instantly cripple the AI
+        exit_code_penalty: 50, // Reduced from 70
+        spiral_penalty: 30,
+        missing_test_command_penalty: 20,
+        subagent_error_penalty: 60,
+        subagent_timeout_penalty: 50
+    },
+    severity_thresholds: {
+        high: 70,
+        medium: 40,
+        low: 20
+    },
+    intervals: {
+        worker_poll_ms: 15 * 60 * 1000,
+        initial_delay_ms: 5000,
+        task_timeout_ms: 30 * 60 * 1000
+    },
+    trust: {
+        stages: {
+            stage_1_observer: 30,
+            stage_2_editor: 60,
+            stage_3_developer: 80,
+        },
+        cold_start: {
+            // 🚀 The most important change: Start at 85 (Developer level)
+            // This allows the AI to perform medium-sized edits right out of the box
+            // without needing to beg for a PLAN.md on every single change.
+            initial_trust: 85,
+            grace_failures: 5, // Give the AI 5 free mistakes before deducting any trust points
+            cold_start_period_ms: 24 * 60 * 60 * 1000,
+        },
+        penalties: {
+            // 🛡️ Forgiving penalties for exploration
+            tool_failure_base: -2, // Was -8. A simple 'ls' typo shouldn't cost 8 points.
+            risky_failure_base: -10, // Was -15.
+            gate_bypass_attempt: -5,
+            failure_streak_multiplier: -2,
+            max_penalty: -20,
+        },
+        rewards: {
+            success_base: 2, // Was 1. Faster recovery
+            subagent_success: 5, // Was 3.
+            tool_success_reward: 0.2, // 👈 Minor reward for tool success, but resets streak!
+            streak_bonus_threshold: 3, // Was 5. Easier to get bonuses
+            streak_bonus: 5,
+            recovery_boost: 5, // Was 3. If trust drops low, it's easier to climb back up
+            max_reward: 15,
+        },
+        limits: {
+            stage_2_max_lines: 50, // Was 10. 10 lines is barely enough to fix a function signature.
+            stage_3_max_lines: 300, // Was 100. Allow substantial feature implementation.
+        },
+        history_limit: 50
+    },
+    deep_reflection: {
+        enabled: true,
+        mode: 'auto',
+        force_checkpoint: true,
+        checkpoint_message: 'Before responding, quick self-check: 1. Task complexity (simple/medium/complex) 2. Information sufficiency (sufficient/need more) 3. If complex or insufficient info, call deep_reflect tool',
+        auto_trigger_conditions: {
+            min_tool_calls: 5,
+            error_rate_threshold: 0.3,
+            complexity_keywords: ['refactor', 'architecture', 'design', 'optimize', 'security', 'critical']
+        },
+        default_model: 'T-01',
+        default_depth: 2,
+        timeout_ms: 60000
+    }
+};
+export class PainConfig {
+    settings = { ...DEFAULT_SETTINGS };
+    filePath;
+    constructor(stateDir) {
+        this.filePath = path.join(stateDir, 'pain_settings.json');
+    }
+    load() {
+        if (fs.existsSync(this.filePath)) {
+            try {
+                const loaded = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+                this.settings = this.deepMerge(DEFAULT_SETTINGS, loaded);
+                this.validate(this.settings);
+            }
+            catch (e) {
+                console.error('[PD] Failed to parse pain_settings.json, using defaults.');
+            }
+        }
+        else {
+            console.log(`[PD:Config] Settings not found at ${this.filePath}, creating with defaults`);
+            this.save();
+        }
+    }
+    save() {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.filePath, JSON.stringify(this.settings, null, 2), 'utf8');
+            console.log(`[PD:Config] Settings saved to ${this.filePath}`);
+        }
+        catch (e) {
+            console.error(`[PD:Config] Failed to save settings: ${String(e)}`);
+        }
+    }
+    deepMerge(target, source) {
+        const output = { ...target };
+        if (source && typeof source === 'object') {
+            Object.keys(source).forEach(key => {
+                // 👈 FIX: Skip if source value is undefined to avoid overwriting defaults
+                if (source[key] === undefined)
+                    return;
+                if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                    if (!(key in target)) {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                    else {
+                        output[key] = this.deepMerge(target[key], source[key]);
+                    }
+                }
+                else {
+                    Object.assign(output, { [key]: source[key] });
+                }
+            });
+        }
+        return output;
+    }
+    /**
+     * Basic validation for critical settings
+     */
+    validate(settings) {
+        // Ensure trust scores stay within 0-100 logical range
+        const s = settings.trust.stages;
+        if (s.stage_1_observer < 0 || s.stage_1_observer > 100)
+            s.stage_1_observer = 30;
+        if (s.stage_2_editor < 0 || s.stage_2_editor > 100)
+            s.stage_2_editor = 60;
+        if (s.stage_3_developer < 0 || s.stage_3_developer > 100)
+            s.stage_3_developer = 80;
+        // Ensure intervals are positive
+        if (settings.intervals.worker_poll_ms < 1000)
+            settings.intervals.worker_poll_ms = 15 * 60 * 1000;
+    }
+    /**
+     * Gets a value using dot notation (e.g. 'thresholds.pain_trigger')
+     */
+    get(keyPath) {
+        const parts = keyPath.split('.');
+        let current = this.settings;
+        for (const part of parts) {
+            if (current === undefined || current[part] === undefined)
+                return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Returns all settings as a plain object.
+     */
+    getAll() {
+        return this.settings;
+    }
+}

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 dictionary;
+    private cache;
+    private asyncQueue;
+    constructor(dictionary: PainDictionary);
+    /**
+     * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
+     */
+    detect(text: string): DetectionResult;
+    private 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/dist/core/detection-funnel.js

@@ -0,0 +1,100 @@
+import { createHash } from 'crypto';
+/**
+ * A simple LRU Cache implementation using Map.
+ */
+class SimpleLRU {
+    maxSize;
+    cache;
+    constructor(maxSize = 100) {
+        this.maxSize = maxSize;
+        this.cache = new Map();
+    }
+    get(key) {
+        const item = this.cache.get(key);
+        if (item !== undefined) {
+            // Refresh: delete and re-insert
+            this.cache.delete(key);
+            this.cache.set(key, item);
+        }
+        return item;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Remove the oldest (first) item
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+}
+/**
+ * Orchestrates the three-layer detection funnel for pain signals.
+ */
+export class DetectionFunnel {
+    dictionary;
+    cache = new SimpleLRU(100);
+    asyncQueue = [];
+    constructor(dictionary) {
+        this.dictionary = dictionary;
+    }
+    /**
+     * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
+     */
+    detect(text) {
+        // --- Layer 1: Exact Match (Sync) ---
+        const exactMatch = this.dictionary.match(text);
+        if (exactMatch) {
+            return {
+                detected: true,
+                severity: exactMatch.severity,
+                ruleId: exactMatch.ruleId,
+                source: 'l1_exact'
+            };
+        }
+        // --- Layer 2: LRU Cache (Sync) ---
+        const hash = this.computeHash(text);
+        const cached = this.cache.get(hash);
+        if (cached) {
+            return {
+                detected: cached.detected,
+                severity: cached.severity,
+                source: 'l2_cache'
+            };
+        }
+        // --- Layer 3: Async Semantic Queue ---
+        this.enqueueAsync(text);
+        return {
+            detected: false,
+            source: 'l3_async_queued'
+        };
+    }
+    computeHash(text) {
+        return createHash('sha256').update(text).digest('hex');
+    }
+    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, result) {
+        const hash = this.computeHash(text);
+        this.cache.set(hash, result);
+    }
+    /**
+     * Retrieves and clears the current asynchronous queue.
+     */
+    flushQueue() {
+        const queue = [...this.asyncQueue];
+        this.asyncQueue = [];
+        return queue;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { DetectionFunnel } from './detection-funnel.js';
+/**
+ * Singleton service to manage the Semantic Detection Funnel.
+ */
+export declare const DetectionService: {
+    /**
+     * Gets or initializes the Detection Funnel instance.
+     * @param stateDir The directory used to initialize the dictionary.
+     */
+    get(stateDir: string): DetectionFunnel;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/dist/core/detection-service.js

@@ -0,0 +1,28 @@
+import { DetectionFunnel } from './detection-funnel.js';
+import { DictionaryService } from './dictionary-service.js';
+let instance = null;
+let lastStateDir = null;
+/**
+ * Singleton service to manage the Semantic Detection Funnel.
+ */
+export const DetectionService = {
+    /**
+     * Gets or initializes the Detection Funnel instance.
+     * @param stateDir The directory used to initialize the dictionary.
+     */
+    get(stateDir) {
+        if (!instance || lastStateDir !== stateDir) {
+            const dictionary = DictionaryService.get(stateDir);
+            instance = new DetectionFunnel(dictionary);
+            lastStateDir = stateDir;
+        }
+        return instance;
+    },
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset() {
+        instance = null;
+        lastStateDir = null;
+    }
+};

package/dist/core/dictionary-service.d.ts

@@ -0,0 +1,15 @@
+import { PainDictionary } from './dictionary.js';
+/**
+ * Singleton service to manage the Pain Dictionary.
+ */
+export declare const DictionaryService: {
+    /**
+     * Gets or initializes the Pain Dictionary instance.
+     * @param stateDir The directory where the dictionary JSON is stored.
+     */
+    get(stateDir: string): PainDictionary;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};