principles-disciple 1.5.4

package/dist/core/path-resolver.js

@@ -0,0 +1,259 @@
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+const DEFAULT_WORKSPACE_SUBPATH = '.openclaw/workspace';
+export const PD_ENV_VARS = {
+    WORKSPACE_DIR: 'PD_WORKSPACE_DIR',
+    STATE_DIR: 'PD_STATE_DIR',
+    DEBUG: 'DEBUG',
+};
+export const PD_ENV_DESCRIPTIONS = {
+    WORKSPACE_DIR: {
+        desc: 'Override the default workspace directory',
+        example: 'PD_WORKSPACE_DIR=/home/user/my-workspace',
+    },
+    STATE_DIR: {
+        desc: 'Override the default state directory (.state)',
+        example: 'PD_STATE_DIR=/home/user/my-workspace/.state',
+    },
+    DEBUG: {
+        desc: 'Enable debug logging for path resolution',
+        example: 'DEBUG=true',
+    },
+};
+export function printEnvVarHelp() {
+    console.log('\n📁 Principles Disciple - Environment Variables\n');
+    console.log('You can customize directory paths using environment variables:\n');
+    for (const [key, varName] of Object.entries(PD_ENV_VARS)) {
+        const info = PD_ENV_DESCRIPTIONS[key];
+        console.log(`  ${varName}`);
+        console.log(`    Description: ${info.desc}`);
+        console.log(`    Example: ${info.example}`);
+        console.log();
+    }
+    console.log('💡 Tips:');
+    console.log('  - These can be set in your shell profile (~/.bashrc, ~/.zshrc)');
+    console.log('  - Or passed when starting OpenClaw gateway');
+    console.log('  - Example: PD_WORKSPACE_DIR=/custom/path openclaw-gateway start\n');
+}
+const PD_CONFIG_FILE = 'principles-disciple.json';
+const PD_CONFIG_LOCATIONS = [
+    path.join(process.cwd(), PD_CONFIG_FILE),
+    path.join(os.homedir(), '.openclaw', PD_CONFIG_FILE),
+    path.join(os.homedir(), '.principles', PD_CONFIG_FILE),
+];
+function findConfigFile() {
+    for (const loc of PD_CONFIG_LOCATIONS) {
+        if (fs.existsSync(loc)) {
+            return loc;
+        }
+    }
+    return null;
+}
+function loadConfigFromFile() {
+    const configPath = findConfigFile();
+    if (!configPath) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const config = JSON.parse(content);
+        console.log(`[PD:PathResolver] Loaded config from: ${configPath}`);
+        return config;
+    }
+    catch (e) {
+        console.warn(`[PD:PathResolver] Failed to load config from ${configPath}: ${String(e)}`);
+        return null;
+    }
+}
+export class PathResolver {
+    workspaceDir = null;
+    stateDir = null;
+    logger;
+    normalizeWorkspace;
+    initialized = false;
+    constructor(options = {}) {
+        this.logger = options.logger;
+        this.normalizeWorkspace = options.normalizeWorkspace ?? true;
+        if (options.workspaceDir) {
+            this.workspaceDir = options.workspaceDir;
+        }
+    }
+    log(level, msg) {
+        const prefix = '[PD:PathResolver]';
+        const fullMsg = `${prefix} ${msg}`;
+        if (process.env.DEBUG === 'true') {
+            console.debug(fullMsg);
+        }
+        switch (level) {
+            case 'debug':
+                this.logger?.debug?.(fullMsg);
+                break;
+            case 'info':
+                this.logger?.info?.(fullMsg) || console.log(fullMsg);
+                break;
+            case 'warn':
+                this.logger?.warn?.(fullMsg) || console.warn(fullMsg);
+                break;
+            case 'error':
+                this.logger?.error?.(fullMsg) || console.error(fullMsg);
+                break;
+        }
+    }
+    detectWorkspaceDir() {
+        const envWorkspace = process.env.PD_WORKSPACE_DIR;
+        if (envWorkspace && envWorkspace.trim()) {
+            this.log('info', `Using workspace from PD_WORKSPACE_DIR: ${envWorkspace}`);
+            return envWorkspace.trim();
+        }
+        const envOpenclaw = process.env.OPENCLAW_WORKSPACE;
+        if (envOpenclaw && envOpenclaw.trim()) {
+            this.log('info', `Using workspace from OPENCLAW_WORKSPACE: ${envOpenclaw}`);
+            return envOpenclaw.trim();
+        }
+        const fileConfig = loadConfigFromFile();
+        if (fileConfig?.workspace) {
+            this.log('info', `Using workspace from config file: ${fileConfig.workspace}`);
+            return fileConfig.workspace;
+        }
+        const homeDir = os.homedir();
+        const defaultWorkspace = path.join(homeDir, DEFAULT_WORKSPACE_SUBPATH);
+        this.log('info', `Using default workspace: ${defaultWorkspace}`);
+        return defaultWorkspace;
+    }
+    normalizePath(inputPath) {
+        let normalized = path.resolve(inputPath);
+        if (this.normalizeWorkspace) {
+            const problematicSuffixes = ['/memory', '/docs'];
+            for (const suffix of problematicSuffixes) {
+                if (normalized.endsWith(suffix)) {
+                    const parent = path.dirname(normalized);
+                    this.log('warn', `Detected subdirectory suffix '${suffix}' in path. Normalized to parent: ${parent}`);
+                    normalized = parent;
+                    break;
+                }
+            }
+        }
+        return normalized;
+    }
+    normalizeWorkspacePath(inputPath) {
+        return this.normalizePath(inputPath);
+    }
+    getWorkspaceDir() {
+        if (this.initialized && this.workspaceDir) {
+            return this.workspaceDir;
+        }
+        let dir = this.detectWorkspaceDir();
+        if (this.normalizeWorkspace) {
+            const originalDir = dir;
+            dir = this.normalizePath(dir);
+            if (originalDir !== dir) {
+                this.log('info', `Workspace path normalized: ${originalDir} -> ${dir}`);
+            }
+        }
+        this.workspaceDir = dir;
+        this.initialized = true;
+        this.log('debug', `Final workspace directory: ${this.workspaceDir}`);
+        return this.workspaceDir;
+    }
+    getStateDir() {
+        if (this.stateDir) {
+            return this.stateDir;
+        }
+        const envStateDir = process.env.PD_STATE_DIR;
+        if (envStateDir && envStateDir.trim()) {
+            this.stateDir = envStateDir.trim();
+            this.log('info', `Using state directory from PD_STATE_DIR: ${this.stateDir}`);
+            return this.stateDir;
+        }
+        const fileConfig = loadConfigFromFile();
+        if (fileConfig?.state) {
+            this.stateDir = fileConfig.state;
+            this.log('info', `Using state directory from config file: ${this.stateDir}`);
+            return this.stateDir;
+        }
+        this.stateDir = path.join(this.getWorkspaceDir(), '.state');
+        this.log('debug', `Computed state directory: ${this.stateDir}`);
+        return this.stateDir;
+    }
+    resolve(key) {
+        const workspace = this.getWorkspaceDir();
+        const state = this.getStateDir();
+        const memory = path.join(workspace, 'memory');
+        const pathMap = {
+            'PROFILE': path.join(workspace, '.principles', 'PROFILE.json'),
+            'PRINCIPLES': path.join(workspace, '.principles', 'PRINCIPLES.md'),
+            'THINKING_OS': path.join(workspace, '.principles', 'THINKING_OS.md'),
+            'KERNEL': path.join(workspace, '.principles', '00-kernel.md'),
+            'DECISION_POLICY': path.join(workspace, '.principles', 'DECISION_POLICY.json'),
+            'MODELS_DIR': path.join(workspace, '.principles', 'models'),
+            'PLAN': path.join(workspace, 'PLAN.md'),
+            'AGENT_SCORECARD': path.join(state, 'AGENT_SCORECARD.json'),
+            'PAIN_FLAG': path.join(state, '.pain_flag'),
+            'EVOLUTION_QUEUE': path.join(state, 'evolution_queue.json'),
+            'EVOLUTION_DIRECTIVE': path.join(state, 'evolution_directive.json'),
+            'WORKBOARD': path.join(state, 'WORKBOARD.json'),
+            'SYSTEM_CAPABILITIES': path.join(state, 'SYSTEM_CAPABILITIES.json'),
+            'PAIN_SETTINGS': path.join(state, 'pain_settings.json'),
+            'PAIN_CANDIDATES': path.join(state, 'pain_candidates.json'),
+            'THINKING_OS_USAGE': path.join(state, 'thinking_os_usage.json'),
+            'DICTIONARY': path.join(state, 'pain_dictionary.json'),
+            'STATE_DIR': state,
+            'LOGS': path.join(memory, 'logs'),
+            'SYSTEM_LOG': path.join(memory, 'logs', 'SYSTEM.log'),
+            'REFLECTION_LOG': path.join(memory, 'reflection-log.md'),
+            'USER_CONTEXT': path.join(memory, 'USER_CONTEXT.md'),
+            'OKR_DIR': path.join(memory, 'okr'),
+            'CURRENT_FOCUS': path.join(memory, 'okr', 'CURRENT_FOCUS.md'),
+            'WEEK_STATE': path.join(memory, 'okr', 'WEEK_STATE.json'),
+            'THINKING_OS_CANDIDATES': path.join(memory, 'THINKING_OS_CANDIDATES.md'),
+            'MEMORY': memory,
+        };
+        const resolved = pathMap[key];
+        if (!resolved) {
+            this.log('warn', `Unknown path key: ${key}`);
+            throw new Error(`Unknown path key: ${key}`);
+        }
+        this.log('debug', `Resolved path for '${key}': ${resolved}`);
+        return resolved;
+    }
+    ensureStateDir() {
+        const stateDir = this.getStateDir();
+        if (!fs.existsSync(stateDir)) {
+            this.log('info', `Creating state directory: ${stateDir}`);
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+    }
+    static createFromHookContext(ctx) {
+        const resolver = new PathResolver();
+        if (ctx?.workspaceDir) {
+            let workspaceDir = ctx.workspaceDir;
+            if (resolver.normalizeWorkspace) {
+                workspaceDir = resolver.normalizePath(workspaceDir);
+            }
+            resolver.workspaceDir = workspaceDir;
+            resolver.initialized = true;
+            resolver.log('info', `Created from hook context with workspace: ${workspaceDir}`);
+        }
+        if (ctx?.stateDir) {
+            resolver.stateDir = ctx.stateDir;
+        }
+        return resolver;
+    }
+}
+export function createDefaultConfig(targetPath) {
+    const defaultConfig = {
+        workspace: path.join(os.homedir(), '.openclaw', 'workspace'),
+        state: path.join(os.homedir(), '.openclaw', 'workspace', '.state'),
+        debug: false,
+    };
+    const target = targetPath || path.join(os.homedir(), '.openclaw', PD_CONFIG_FILE);
+    const dir = path.dirname(target);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(target, JSON.stringify(defaultConfig, null, 2), 'utf8');
+    console.log(`✅ Created default config at: ${target}`);
+    console.log(`   You can edit this file to customize paths.`);
+    return target;
+}

package/dist/core/paths.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Principles Disciple Directory Constants
+ * Establishing a logical separation between Identity, State, and Memory.
+ */
+export declare const PD_DIRS: {
+    /** 🧬 Core configuration, identity, and kernel rules (hidden) */
+    IDENTITY: string;
+    /** 🧠 Deep Reflection mental models */
+    MODELS: string;
+    /** ⚡ Volatile operational data, queues, and task status (hidden) */
+    STATE: string;
+    /** 💾 Historical records, logs, and long-term memory */
+    MEMORY: string;
+    /** 🎯 Strategic objectives and focus areas */
+    OKR: string;
+    /** 📁 Internal logs directory */
+    LOGS: string;
+    /** 🧠 Session persistence directory */
+    SESSIONS: string;
+    /** 🩹 Semantic pain samples for L3 retrieval */
+    PAIN_SAMPLES: string;
+};
+/**
+ * Standard File Path Mappings
+ */
+export declare const PD_FILES: {
+    PROFILE: string;
+    PRINCIPLES: string;
+    THINKING_OS: string;
+    KERNEL: string;
+    DECISION_POLICY: string;
+    MODELS_DIR: string;
+    STATE_DIR: string;
+    EVOLUTION_QUEUE: string;
+    EVOLUTION_DIRECTIVE: string;
+    WORKBOARD: string;
+    AGENT_SCORECARD: string;
+    PAIN_FLAG: string;
+    SYSTEM_CAPABILITIES: string;
+    PAIN_SETTINGS: string;
+    PAIN_CANDIDATES: string;
+    THINKING_OS_USAGE: string;
+    SESSION_DIR: string;
+    DICTIONARY: string;
+    PLAN: string;
+    MEMORY_MD: string;
+    HEARTBEAT: string;
+    SYSTEM_LOG: string;
+    REFLECTION_LOG: string;
+    USER_CONTEXT: string;
+    OKR_DIR: string;
+    CURRENT_FOCUS: string;
+    WEEK_STATE: string;
+    THINKING_OS_CANDIDATES: string;
+    SEMANTIC_PAIN: string;
+};
+/**
+ * Resolves a PD file path within a given workspace.
+ */
+export declare function resolvePdPath(workspaceDir: string, fileKey: keyof typeof PD_FILES): string;

package/dist/core/paths.js

@@ -0,0 +1,67 @@
+import * as path from 'path';
+/**
+ * Principles Disciple Directory Constants
+ * Establishing a logical separation between Identity, State, and Memory.
+ */
+export const PD_DIRS = {
+    /** 🧬 Core configuration, identity, and kernel rules (hidden) */
+    IDENTITY: '.principles',
+    /** 🧠 Deep Reflection mental models */
+    MODELS: path.join('.principles', 'models'),
+    /** ⚡ Volatile operational data, queues, and task status (hidden) */
+    STATE: '.state',
+    /** 💾 Historical records, logs, and long-term memory */
+    MEMORY: 'memory',
+    /** 🎯 Strategic objectives and focus areas */
+    OKR: path.join('memory', 'okr'),
+    /** 📁 Internal logs directory */
+    LOGS: path.join('memory', 'logs'),
+    /** 🧠 Session persistence directory */
+    SESSIONS: path.join('.state', 'sessions'),
+    /** 🩹 Semantic pain samples for L3 retrieval */
+    PAIN_SAMPLES: path.join('memory', 'pain'),
+};
+/**
+ * Standard File Path Mappings
+ */
+export const PD_FILES = {
+    // Identity Layer
+    PROFILE: path.join(PD_DIRS.IDENTITY, 'PROFILE.json'),
+    PRINCIPLES: path.join(PD_DIRS.IDENTITY, 'PRINCIPLES.md'),
+    THINKING_OS: path.join(PD_DIRS.IDENTITY, 'THINKING_OS.md'),
+    KERNEL: path.join(PD_DIRS.IDENTITY, '00-kernel.md'),
+    DECISION_POLICY: path.join(PD_DIRS.IDENTITY, 'DECISION_POLICY.json'),
+    MODELS_DIR: PD_DIRS.MODELS,
+    // State Layer
+    STATE_DIR: PD_DIRS.STATE,
+    EVOLUTION_QUEUE: path.join(PD_DIRS.STATE, 'evolution_queue.json'),
+    EVOLUTION_DIRECTIVE: path.join(PD_DIRS.STATE, 'evolution_directive.json'),
+    WORKBOARD: path.join(PD_DIRS.STATE, 'WORKBOARD.json'),
+    AGENT_SCORECARD: path.join(PD_DIRS.STATE, 'AGENT_SCORECARD.json'),
+    PAIN_FLAG: path.join(PD_DIRS.STATE, '.pain_flag'),
+    SYSTEM_CAPABILITIES: path.join(PD_DIRS.STATE, 'SYSTEM_CAPABILITIES.json'),
+    PAIN_SETTINGS: path.join(PD_DIRS.STATE, 'pain_settings.json'),
+    PAIN_CANDIDATES: path.join(PD_DIRS.STATE, 'pain_candidates.json'),
+    THINKING_OS_USAGE: path.join(PD_DIRS.STATE, 'thinking_os_usage.json'),
+    SESSION_DIR: PD_DIRS.SESSIONS,
+    DICTIONARY: path.join(PD_DIRS.STATE, 'pain_dictionary.json'),
+    // Workflow Layer (Project Root)
+    PLAN: 'PLAN.md',
+    MEMORY_MD: 'MEMORY.md',
+    HEARTBEAT: 'HEARTBEAT.md',
+    // Memory Layer
+    SYSTEM_LOG: path.join(PD_DIRS.LOGS, 'SYSTEM.log'),
+    REFLECTION_LOG: path.join(PD_DIRS.MEMORY, 'reflection-log.md'),
+    USER_CONTEXT: path.join(PD_DIRS.MEMORY, 'USER_CONTEXT.md'),
+    OKR_DIR: PD_DIRS.OKR,
+    CURRENT_FOCUS: path.join(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
+    WEEK_STATE: path.join(PD_DIRS.OKR, 'WEEK_STATE.json'),
+    THINKING_OS_CANDIDATES: path.join(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
+    SEMANTIC_PAIN: path.join(PD_DIRS.PAIN_SAMPLES, 'confusion_samples.md'),
+};
+/**
+ * Resolves a PD file path within a given workspace.
+ */
+export function resolvePdPath(workspaceDir, fileKey) {
+    return path.join(workspaceDir, PD_FILES[fileKey]);
+}

package/dist/core/profile.d.ts

@@ -0,0 +1,62 @@
+export declare const PROFILE_AUDIT_LEVELS: Set<string>;
+export declare const PROFILE_EVOLUTION_MODES: Set<string>;
+export declare const PROFILE_TEST_LEVELS: Set<string>;
+export declare const PROFILE_DEFAULTS: {
+    audit_level: string;
+    risk_paths: string[];
+    evolution_mode: string;
+    gate: {
+        require_plan_for_risk_paths: boolean;
+        require_audit_before_write: boolean;
+        require_reviewer_after_write: boolean;
+    };
+    tests: {
+        on_change: string;
+        on_risk_change: string;
+        commands: Record<string, string>;
+    };
+    pain: {
+        soft_capture_threshold: number;
+        adaptive: {
+            enabled: boolean;
+            spiral_boost: number;
+            min_threshold: number;
+            max_threshold: number;
+            backlog_trigger: number;
+            hard_failure_trigger: number;
+            low_recent_success_boost: number;
+            high_recent_pain_boost: number;
+        };
+    };
+    lifecycle: {
+        enabled: boolean;
+        heartbeat_stale_hours: number;
+    };
+    progressive_gate: {
+        enabled: boolean;
+        plan_approvals: {
+            enabled: boolean;
+            max_lines_override: number;
+            allowed_patterns: string[];
+            allowed_operations: string[];
+        };
+    };
+    edit_verification: {
+        enabled: boolean;
+        max_file_size_bytes: number;
+        fuzzy_match_enabled: boolean;
+        fuzzy_match_threshold: number;
+        skip_large_file_action: "warn" | "block";
+    };
+    thinking_checkpoint: {
+        enabled: boolean;
+        window_ms: number;
+        high_risk_tools: string[];
+    };
+    custom_guards: Array<{
+        pattern: string;
+        message: string;
+        severity: string;
+    }>;
+};
+export declare function normalizeProfile(rawProfile: any): any;

package/dist/core/profile.js

@@ -0,0 +1,210 @@
+export const PROFILE_AUDIT_LEVELS = new Set(["low", "medium", "high"]);
+export const PROFILE_EVOLUTION_MODES = new Set(["realtime", "async"]);
+export const PROFILE_TEST_LEVELS = new Set(["smoke", "unit", "full"]);
+export const PROFILE_DEFAULTS = {
+    audit_level: "medium",
+    risk_paths: [],
+    evolution_mode: "realtime",
+    gate: {
+        require_plan_for_risk_paths: true,
+        require_audit_before_write: true,
+        require_reviewer_after_write: true,
+    },
+    tests: {
+        on_change: "smoke",
+        on_risk_change: "unit",
+        commands: {},
+    },
+    pain: {
+        soft_capture_threshold: 30,
+        adaptive: {
+            enabled: true,
+            spiral_boost: 20,
+            min_threshold: 15,
+            max_threshold: 70,
+            backlog_trigger: 6,
+            hard_failure_trigger: 1,
+            low_recent_success_boost: 15,
+            high_recent_pain_boost: 10,
+        },
+    },
+    lifecycle: {
+        enabled: true,
+        heartbeat_stale_hours: 72,
+    },
+    progressive_gate: {
+        enabled: true,
+        plan_approvals: {
+            enabled: false,
+            max_lines_override: -1,
+            allowed_patterns: [],
+            allowed_operations: [],
+        },
+    },
+    edit_verification: {
+        enabled: true,
+        max_file_size_bytes: 10 * 1024 * 1024, // 10MB
+        fuzzy_match_enabled: true,
+        fuzzy_match_threshold: 0.8,
+        skip_large_file_action: "warn", // "warn" or "block"
+    },
+    thinking_checkpoint: {
+        enabled: false, // Default OFF to avoid blocking new users
+        window_ms: 5 * 60 * 1000, // 5 minute window
+        high_risk_tools: ['run_shell_command', 'delete_file', 'move_file', 'pd_spawn_agent'],
+    },
+    custom_guards: [],
+};
+export function normalizeProfile(rawProfile) {
+    const defaults = JSON.parse(JSON.stringify(PROFILE_DEFAULTS));
+    const warnings = [];
+    const normalized = { ...defaults };
+    let invalid = false;
+    if (!rawProfile || typeof rawProfile !== "object" || Array.isArray(rawProfile)) {
+        warnings.push("PROFILE root must be an object; defaults applied.");
+        invalid = true;
+    }
+    else {
+        // Merge known fields (Support both snake_case and camelCase)
+        const auditLevel = rawProfile.audit_level ?? rawProfile.auditLevel;
+        if (PROFILE_AUDIT_LEVELS.has(auditLevel)) {
+            normalized.audit_level = auditLevel;
+        }
+        else if (auditLevel !== undefined) {
+            warnings.push(`Invalid audit_level '${auditLevel}'`);
+        }
+        const evolutionMode = rawProfile.evolution_mode ?? rawProfile.evolutionMode;
+        if (PROFILE_EVOLUTION_MODES.has(evolutionMode)) {
+            normalized.evolution_mode = evolutionMode;
+        }
+        else if (evolutionMode !== undefined) {
+            warnings.push(`Invalid evolution_mode '${evolutionMode}'`);
+        }
+        const riskPaths = rawProfile.risk_paths ?? rawProfile.riskPaths;
+        if (Array.isArray(riskPaths)) {
+            normalized.risk_paths = riskPaths.filter((p) => typeof p === 'string');
+        }
+        else if (typeof riskPaths === 'string') {
+            normalized.risk_paths = [riskPaths];
+        }
+        else if (riskPaths !== undefined) {
+            warnings.push("risk_paths must be an array of strings");
+        }
+        // Gate settings
+        if (rawProfile.gate && typeof rawProfile.gate === 'object') {
+            const g = rawProfile.gate;
+            normalized.gate.require_plan_for_risk_paths = g.require_plan_for_risk_paths ?? g.requirePlanForRiskPaths ?? defaults.gate.require_plan_for_risk_paths;
+            normalized.gate.require_audit_before_write = g.require_audit_before_write ?? g.requireAuditBeforeWrite ?? defaults.gate.require_audit_before_write;
+            normalized.gate.require_reviewer_after_write = g.require_reviewer_after_write ?? g.requireReviewerAfterWrite ?? defaults.gate.require_reviewer_after_write;
+        }
+        // Progressive Gate
+        if (rawProfile.progressive_gate && typeof rawProfile.progressive_gate === 'object') {
+            const pg = rawProfile.progressive_gate;
+            normalized.progressive_gate.enabled = pg.enabled ?? pg.enabled ?? defaults.progressive_gate.enabled;
+            // Plan approvals configuration
+            if (pg.plan_approvals && typeof pg.plan_approvals === 'object') {
+                const pa = pg.plan_approvals;
+                normalized.progressive_gate.plan_approvals.enabled = pa.enabled ?? pa.planApprovals ?? defaults.progressive_gate.plan_approvals.enabled;
+                const maxLines = pa.max_lines_override ?? pa.maxLinesOverride;
+                if (typeof maxLines === 'number' && maxLines >= -1) {
+                    normalized.progressive_gate.plan_approvals.max_lines_override = maxLines;
+                }
+                if (Array.isArray(pa.allowed_patterns)) {
+                    normalized.progressive_gate.plan_approvals.allowed_patterns = pa.allowed_patterns.filter((p) => typeof p === 'string');
+                }
+                if (Array.isArray(pa.allowed_operations)) {
+                    normalized.progressive_gate.plan_approvals.allowed_operations = pa.allowed_operations.filter((o) => typeof o === 'string');
+                }
+            }
+        }
+        else if (rawProfile.progressiveGate && typeof rawProfile.progressiveGate === 'object') {
+            const pg = rawProfile.progressiveGate;
+            normalized.progressive_gate.enabled = pg.enabled ?? defaults.progressive_gate.enabled;
+            // Plan approvals configuration (camelCase)
+            if (pg.planApprovals && typeof pg.planApprovals === 'object') {
+                const pa = pg.planApprovals;
+                normalized.progressive_gate.plan_approvals.enabled = pa.enabled ?? defaults.progressive_gate.plan_approvals.enabled;
+                const maxLines = pa.maxLinesOverride;
+                if (typeof maxLines === 'number' && maxLines >= -1) {
+                    normalized.progressive_gate.plan_approvals.max_lines_override = maxLines;
+                }
+                if (Array.isArray(pa.allowedPatterns)) {
+                    normalized.progressive_gate.plan_approvals.allowed_patterns = pa.allowedPatterns.filter((p) => typeof p === 'string');
+                }
+                if (Array.isArray(pa.allowedOperations)) {
+                    normalized.progressive_gate.plan_approvals.allowed_operations = pa.allowedOperations.filter((o) => typeof o === 'string');
+                }
+            }
+        }
+        // Edit verification settings (P-03)
+        const evRaw = rawProfile.edit_verification ?? rawProfile.editVerification;
+        if (evRaw && typeof evRaw === 'object') {
+            normalized.edit_verification.enabled = evRaw.enabled ?? defaults.edit_verification.enabled;
+            const maxSize = evRaw.max_file_size_bytes ?? evRaw.maxFileSizeBytes;
+            if (typeof maxSize === 'number' && maxSize >= 0) {
+                normalized.edit_verification.max_file_size_bytes = maxSize;
+            }
+            normalized.edit_verification.fuzzy_match_enabled = evRaw.fuzzy_match_enabled ?? evRaw.fuzzyMatchEnabled ?? defaults.edit_verification.fuzzy_match_enabled;
+            const threshold = evRaw.fuzzy_match_threshold ?? evRaw.fuzzyMatchThreshold;
+            if (typeof threshold === 'number' && threshold > 0 && threshold <= 1) {
+                normalized.edit_verification.fuzzy_match_threshold = threshold;
+            }
+            const action = evRaw.skip_large_file_action ?? evRaw.skipLargeFileAction;
+            if (typeof action === 'string' && ['warn', 'block'].includes(action)) {
+                normalized.edit_verification.skip_large_file_action = action;
+            }
+        }
+        // Test settings
+        if (rawProfile.tests && typeof rawProfile.tests === 'object') {
+            const t = rawProfile.tests;
+            const onChange = t.on_change ?? t.onChange;
+            if (PROFILE_TEST_LEVELS.has(onChange)) {
+                normalized.tests.on_change = onChange;
+            }
+            const onRiskChange = t.on_risk_change ?? t.onRiskChange;
+            if (PROFILE_TEST_LEVELS.has(onRiskChange)) {
+                normalized.tests.on_risk_change = onRiskChange;
+            }
+            if (t.commands && typeof t.commands === 'object') {
+                normalized.tests.commands = { ...defaults.tests.commands, ...t.commands };
+            }
+        }
+        // Pain settings
+        if (rawProfile.pain && typeof rawProfile.pain === 'object') {
+            const p = rawProfile.pain;
+            normalized.pain.soft_capture_threshold = p.soft_capture_threshold ?? p.softCaptureThreshold ?? defaults.pain.soft_capture_threshold;
+            if (p.adaptive && typeof p.adaptive === 'object') {
+                normalized.pain.adaptive = { ...defaults.pain.adaptive, ...p.adaptive };
+            }
+        }
+        // Thinking OS Checkpoint settings (P-10)
+        const tcRaw = rawProfile.thinking_checkpoint ?? rawProfile.thinkingCheckpoint;
+        if (tcRaw && typeof tcRaw === 'object') {
+            normalized.thinking_checkpoint.enabled = tcRaw.enabled ?? defaults.thinking_checkpoint.enabled;
+            const windowMs = tcRaw.window_ms ?? tcRaw.windowMs;
+            if (typeof windowMs === 'number' && windowMs > 0) {
+                normalized.thinking_checkpoint.window_ms = windowMs;
+            }
+            if (Array.isArray(tcRaw.high_risk_tools ?? tcRaw.highRiskTools)) {
+                normalized.thinking_checkpoint.high_risk_tools = (tcRaw.high_risk_tools ?? tcRaw.highRiskTools).filter((t) => typeof t === 'string');
+            }
+        }
+        if (Array.isArray(rawProfile.custom_guards)) {
+            normalized.custom_guards = rawProfile.custom_guards.map((item) => {
+                let severity = "error";
+                const itemSeverity = item.severity;
+                if (itemSeverity && ["info", "warning", "error", "fatal"].includes(String(itemSeverity).toLowerCase())) {
+                    severity = String(itemSeverity).toLowerCase();
+                }
+                return {
+                    pattern: String(item.pattern || ""),
+                    message: String(item.message || "Custom guard triggered"),
+                    severity,
+                };
+            }).filter((item) => item.pattern);
+        }
+    }
+    normalized._profile_invalid = invalid;
+    normalized._profile_warnings = warnings;
+    return normalized;
+}

package/dist/core/risk-calculator.d.ts

@@ -0,0 +1,7 @@
+export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+export interface FileModification {
+    toolName: string;
+    params: any;
+}
+export declare function estimateLineChanges(modification: FileModification): number;
+export declare function assessRiskLevel(filePath: string, modification: FileModification, riskPaths: string[]): RiskLevel;