principles-disciple 1.5.4 → 1.7.0

package/dist/core/focus-history.js

@@ -0,0 +1,266 @@
+/**
+ * CURRENT_FOCUS 历史版本管理
+ *
+ * 功能：
+ * - 压缩时备份当前版本到历史目录
+ * - 清理过期历史版本
+ * - 读取历史版本（用于 full 模式）
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * 简单的日志记录器
+ */
+function logError(message, error) {
+    const timestamp = new Date().toISOString();
+    const errorStr = error instanceof Error ? error.message : String(error);
+    console.error(`[focus-history] ${timestamp} ERROR: ${message}${errorStr ? ' - ' + errorStr : ''}`);
+}
+/** 历史版本保留数量 */
+const MAX_HISTORY_FILES = 10;
+/** full 模式读取的历史版本数 */
+const FULL_MODE_HISTORY_COUNT = 3;
+/**
+ * 获取历史目录路径
+ */
+export function getHistoryDir(focusPath) {
+    return path.join(path.dirname(focusPath), '.history');
+}
+/**
+ * 从 CURRENT_FOCUS.md 提取版本号
+ * 支持整数和小数版本（如 v1, v1.1, v1.2）
+ */
+export function extractVersion(content) {
+    const match = content.match(/\*\*版本\*\*:\s*v([\d.]+)/i);
+    return match ? match[1] : '1';
+}
+/**
+ * 从 CURRENT_FOCUS.md 提取更新日期
+ */
+export function extractDate(content) {
+    const match = content.match(/\*\*更新\*\*:\s*(\d{4}-\d{2}-\d{2})/);
+    return match ? match[1] : new Date().toISOString().split('T')[0];
+}
+/**
+ * 备份当前版本到历史目录
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param content 当前内容
+ * @returns 备份文件路径，失败返回 null
+ */
+export function backupToHistory(focusPath, content) {
+    try {
+        const historyDir = getHistoryDir(focusPath);
+        // 确保历史目录存在
+        if (!fs.existsSync(historyDir)) {
+            try {
+                fs.mkdirSync(historyDir, { recursive: true });
+            }
+            catch (error) {
+                logError(`Failed to create history directory: ${historyDir}`, error);
+                return null;
+            }
+        }
+        const version = extractVersion(content);
+        const date = extractDate(content);
+        // 使用时间戳作为唯一标识，避免同名冲突
+        const timestamp = Date.now();
+        const backupName = `CURRENT_FOCUS.v${version}.${date}.${timestamp}.md`;
+        const backupPath = path.join(historyDir, backupName);
+        // 如果备份已存在，跳过
+        if (fs.existsSync(backupPath)) {
+            return null;
+        }
+        try {
+            fs.writeFileSync(backupPath, content, 'utf-8');
+            return backupPath;
+        }
+        catch (error) {
+            logError(`Failed to write backup file: ${backupPath}`, error);
+            return null;
+        }
+    }
+    catch (error) {
+        logError('Unexpected error in backupToHistory', error);
+        return null;
+    }
+}
+/**
+ * 清理过期历史版本
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param maxFiles 最大保留数量
+ */
+export function cleanupHistory(focusPath, maxFiles = MAX_HISTORY_FILES) {
+    try {
+        const historyDir = getHistoryDir(focusPath);
+        if (!fs.existsSync(historyDir)) {
+            return;
+        }
+        // 获取所有历史文件并按修改时间排序（最新的在前）
+        const files = fs.readdirSync(historyDir)
+            .filter(f => f.startsWith('CURRENT_FOCUS.v') && f.endsWith('.md'))
+            .map(f => ({
+            name: f,
+            path: path.join(historyDir, f),
+            mtime: fs.statSync(path.join(historyDir, f)).mtime.getTime()
+        }))
+            .sort((a, b) => b.mtime - a.mtime);
+        // 删除超出数量的文件
+        const toDelete = files.slice(maxFiles);
+        for (const file of toDelete) {
+            try {
+                fs.unlinkSync(file.path);
+            }
+            catch (error) {
+                // 单个文件删除失败不应中断整个清理过程
+                logError(`Failed to delete history file: ${file.path}`, error);
+            }
+        }
+    }
+    catch (error) {
+        logError('Unexpected error in cleanupHistory', error);
+    }
+}
+/**
+ * 获取历史版本列表
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param count 获取数量
+ * @returns 历史版本内容数组（按时间倒序）
+ */
+export function getHistoryVersions(focusPath, count = FULL_MODE_HISTORY_COUNT) {
+    const historyDir = getHistoryDir(focusPath);
+    if (!fs.existsSync(historyDir)) {
+        return [];
+    }
+    // 获取所有历史文件并按修改时间排序（最新的在前）
+    const files = fs.readdirSync(historyDir)
+        .filter(f => f.startsWith('CURRENT_FOCUS.v') && f.endsWith('.md'))
+        .map(f => ({
+        path: path.join(historyDir, f),
+        mtime: fs.statSync(path.join(historyDir, f)).mtime.getTime()
+    }))
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, count);
+    return files.map(f => fs.readFileSync(f.path, 'utf-8'));
+}
+/**
+ * 压缩 CURRENT_FOCUS.md
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param newContent 新内容
+ * @returns 压缩后的信息
+ */
+export function compressFocus(focusPath, newContent) {
+    // 读取当前内容
+    let oldContent = '';
+    if (fs.existsSync(focusPath)) {
+        oldContent = fs.readFileSync(focusPath, 'utf-8');
+    }
+    // 备份当前版本
+    const backupPath = oldContent ? backupToHistory(focusPath, oldContent) : null;
+    // 递增版本号（支持小数版本）
+    const oldVersion = extractVersion(oldContent);
+    // 解析版本号并递增
+    const versionParts = oldVersion.split('.');
+    const majorVersion = parseInt(versionParts[0], 10) || 1;
+    const newVersion = `${majorVersion + 1}`;
+    const today = new Date().toISOString().split('T')[0];
+    // 更新版本号和日期
+    const updatedContent = newContent
+        .replace(/\*\*版本\*\*:\s*v[\d.]+/i, `**版本**: v${newVersion}`)
+        .replace(/\*\*更新\*\*:\s*\d{4}-\d{2}-\d{2}/, `**更新**: ${today}`);
+    // 写入新内容
+    fs.writeFileSync(focusPath, updatedContent, 'utf-8');
+    // 清理过期历史
+    const historyDir = getHistoryDir(focusPath);
+    const beforeCount = fs.existsSync(historyDir)
+        ? fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v')).length
+        : 0;
+    cleanupHistory(focusPath);
+    const afterCount = fs.existsSync(historyDir)
+        ? fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v')).length
+        : 0;
+    return {
+        backupPath,
+        cleanedCount: beforeCount - afterCount
+    };
+}
+/**
+ * 智能摘要提取
+ *
+ * 优先提取关键章节，确保不丢失重要信息
+ * 对于非结构化内容，回退到简单的行截取
+ *
+ * @param content CURRENT_FOCUS.md 内容
+ * @param maxLines 最大行数
+ */
+export function extractSummary(content, maxLines = 30) {
+    const lines = content.split('\n');
+    const sections = {
+        header: [], // 标题和元数据
+        snapshot: [], // 状态快照
+        current: [], // 当前任务
+        nextSteps: [], // 下一步
+        reference: [] // 参考
+    };
+    let currentSection = 'header';
+    let hasStructuredSections = false;
+    for (const line of lines) {
+        // 识别章节（使用更宽松的匹配，支持不同格式）
+        const trimmedLine = line.trim();
+        // 使用正则匹配，支持 h1-h3 和多种格式
+        if (/^#{1,3}\s*.*状态快照|📍/.test(trimmedLine)) {
+            currentSection = 'snapshot';
+            hasStructuredSections = true;
+        }
+        else if (/^#{1,3}\s*.*当前任务|🔄/.test(trimmedLine)) {
+            currentSection = 'current';
+            hasStructuredSections = true;
+        }
+        else if (/^#{1,3}\s*.*下一步|➡️/.test(trimmedLine)) {
+            currentSection = 'nextSteps';
+            hasStructuredSections = true;
+        }
+        else if (/^#{1,3}\s*.*参考|📎/.test(trimmedLine)) {
+            currentSection = 'reference';
+            hasStructuredSections = true;
+        }
+        else if (trimmedLine === '---') {
+            continue; // 跳过分隔线
+        }
+        else if (line.startsWith('<!--')) {
+            continue; // 跳过注释
+        }
+        sections[currentSection].push(line);
+    }
+    // 如果没有结构化章节，回退到简单的行截取
+    if (!hasStructuredSections) {
+        const result = lines.slice(0, maxLines);
+        if (lines.length > maxLines) {
+            result.push('');
+            result.push('...[truncated, see CURRENT_FOCUS.md for full context]');
+        }
+        return result.join('\n');
+    }
+    // 按优先级拼接
+    const result = [
+        ...sections.header.slice(0, 5), // 标题 + 元数据
+        '',
+        '---',
+        '',
+        ...sections.snapshot.slice(0, 10), // 状态快照
+        '',
+        ...sections.nextSteps.slice(0, 10), // 下一步（优先级高）
+        '',
+        ...sections.current.slice(0, 15), // 当前任务
+    ];
+    // 限制总行数
+    const trimmed = result.slice(0, maxLines);
+    if (result.length > maxLines) {
+        trimmed.push('');
+        trimmed.push('...[truncated, see CURRENT_FOCUS.md for full context]');
+    }
+    return trimmed.join('\n');
+}

package/dist/core/init.js

@@ -2,6 +2,15 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { PD_DIRS } from './paths.js';
+import { defaultContextConfig } from '../types.js';
+/**
+ * Default PROFILE.json content
+ */
+const DEFAULT_PROFILE = {
+    name: "Principles Disciple Agent",
+    version: "1.0.0",
+    contextInjection: defaultContextConfig
+};
 /**
  * Ensures that the workspace has the necessary template files for Principles Disciple.
  * This function flattens 'core' templates to the root so OpenClaw can find them.
@@ -47,6 +56,17 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
             }
             copyRecursiveSync(painTemplatesDir, painDestDir, api);
         }
+        // 4. Initialize PROFILE.json with default contextInjection config
+        const principlesDir = path.join(workspaceDir, PD_DIRS.IDENTITY);
+        const profilePath = path.join(principlesDir, 'PROFILE.json');
+        if (!fs.existsSync(profilePath)) {
+            // Ensure .principles directory exists
+            if (!fs.existsSync(principlesDir)) {
+                fs.mkdirSync(principlesDir, { recursive: true });
+            }
+            fs.writeFileSync(profilePath, JSON.stringify(DEFAULT_PROFILE, null, 2), 'utf-8');
+            api.logger.info(`[PD] Initialized PROFILE.json with default contextInjection config`);
+        }
     }
     catch (err) {
         api.logger.error(`[PD] Failed to initialize workspace templates: ${String(err)}`);
@@ -54,12 +74,15 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
 }
 /**
  * Standard recursive copy that preserves directory structure.
+ * Special handling: maps 'okr' directory to 'memory/okr' for runtime compatibility.
  */
 function copyRecursiveSync(srcDir, destDir, api) {
     const items = fs.readdirSync(srcDir);
     for (const item of items) {
         const srcPath = path.join(srcDir, item);
-        const destPath = path.join(destDir, item);
+        // Special mapping: okr -> memory/okr (runtime path expects memory/okr/)
+        const destItemName = item === 'okr' ? path.join('memory', 'okr') : item;
+        const destPath = path.join(destDir, destItemName);
         const stat = fs.statSync(srcPath);
         if (stat.isDirectory()) {
             if (!fs.existsSync(destPath)) {
@@ -69,13 +92,13 @@ function copyRecursiveSync(srcDir, destDir, api) {
         }
         else {
             if (!fs.existsSync(destPath)) {
-                try {
-                    fs.copyFileSync(srcPath, destPath);
-                }
-                catch (err) {
-                    if ('logger' in api)
-                        api.logger.warn(`[PD] Failed to copy ${item}: ${String(err)}`);
+                // Ensure parent directory exists
+                const destParent = path.dirname(destPath);
+                if (!fs.existsSync(destParent)) {
+                    fs.mkdirSync(destParent, { recursive: true });
                 }
+                fs.copyFileSync(srcPath, destPath);
+                api.logger.info(`[PD] Copied: ${destItemName}`);
             }
         }
     }

package/dist/core/migration.js

@@ -12,14 +12,12 @@ export function migrateDirectoryStructure(api, workspaceDir) {
         // Comprehensive migration map covering ALL legacy locations
         const migrationMap = [
             // From docs/
-            { legacy: path.join(legacyDocsDir, 'PROFILE.json'), newKey: 'PROFILE' },
             { legacy: path.join(legacyDocsDir, 'PRINCIPLES.md'), newKey: 'PRINCIPLES' },
             { legacy: path.join(legacyDocsDir, 'THINKING_OS.md'), newKey: 'THINKING_OS' },
             { legacy: path.join(legacyDocsDir, '00-kernel.md'), newKey: 'KERNEL' },
             { legacy: path.join(legacyDocsDir, 'DECISION_POLICY.json'), newKey: 'DECISION_POLICY' },
             { legacy: path.join(legacyDocsDir, 'PLAN.md'), newKey: 'PLAN' },
             { legacy: path.join(legacyDocsDir, 'evolution_queue.json'), newKey: 'EVOLUTION_QUEUE' },
-            { legacy: path.join(legacyDocsDir, 'AGENT_SCORECARD.json'), newKey: 'AGENT_SCORECARD' },
             { legacy: path.join(legacyDocsDir, '.pain_flag'), newKey: 'PAIN_FLAG' },
             { legacy: path.join(legacyDocsDir, 'SYSTEM_CAPABILITIES.json'), newKey: 'SYSTEM_CAPABILITIES' },
             { legacy: path.join(legacyDocsDir, 'SYSTEM.log'), newKey: 'SYSTEM_LOG' },

package/dist/core/path-resolver.d.ts

@@ -24,11 +24,14 @@ export interface PDConfig {
     debug?: boolean;
 }
 export declare class PathResolver {
+    private static extensionRoot;
     private workspaceDir;
     private stateDir;
     private readonly logger?;
     private readonly normalizeWorkspace;
     private initialized;
+    static setExtensionRoot(extensionRootPath: string): void;
+    static getExtensionRoot(): string | null;
     constructor(options?: PathResolverOptions);
     private log;
     private detectWorkspaceDir;

package/dist/core/path-resolver.js

@@ -42,6 +42,21 @@ const PD_CONFIG_LOCATIONS = [
     path.join(os.homedir(), '.openclaw', PD_CONFIG_FILE),
     path.join(os.homedir(), '.principles', PD_CONFIG_FILE),
 ];
+function isWindowsPath(inputPath) {
+    return /^[A-Za-z]:[\\/]/.test(inputPath) || inputPath.startsWith('\\\\');
+}
+function isPosixAbsolutePath(inputPath) {
+    return inputPath.startsWith('/');
+}
+function getPathApi(inputPath) {
+    if (isWindowsPath(inputPath)) {
+        return path.win32;
+    }
+    if (isPosixAbsolutePath(inputPath)) {
+        return path.posix;
+    }
+    return path;
+}
 function findConfigFile() {
     for (const loc of PD_CONFIG_LOCATIONS) {
         if (fs.existsSync(loc)) {
@@ -67,16 +82,34 @@ function loadConfigFromFile() {
     }
 }
 export class PathResolver {
+    static extensionRoot = null;
     workspaceDir = null;
     stateDir = null;
     logger;
     normalizeWorkspace;
     initialized = false;
+    static setExtensionRoot(extensionRootPath) {
+        if (!extensionRootPath || !extensionRootPath.trim()) {
+            return;
+        }
+        const trimmed = extensionRootPath.trim();
+        const pathApi = getPathApi(trimmed);
+        PathResolver.extensionRoot = pathApi.normalize(trimmed);
+    }
+    static getExtensionRoot() {
+        return PathResolver.extensionRoot;
+    }
     constructor(options = {}) {
         this.logger = options.logger;
         this.normalizeWorkspace = options.normalizeWorkspace ?? true;
         if (options.workspaceDir) {
-            this.workspaceDir = options.workspaceDir;
+            const original = options.workspaceDir;
+            const normalized = this.normalizeWorkspace ? this.normalizePath(original) : original;
+            if (original !== normalized) {
+                this.log('info', `Workspace path normalized: ${original} -> ${normalized}`);
+            }
+            this.workspaceDir = normalized;
+            this.initialized = true;
         }
     }
     log(level, msg) {
@@ -122,12 +155,13 @@ export class PathResolver {
         return defaultWorkspace;
     }
     normalizePath(inputPath) {
-        let normalized = path.resolve(inputPath);
+        const pathApi = getPathApi(inputPath);
+        let normalized = pathApi === path ? path.resolve(inputPath) : pathApi.normalize(inputPath);
         if (this.normalizeWorkspace) {
-            const problematicSuffixes = ['/memory', '/docs'];
+            const problematicSuffixes = ['/memory', '/docs', '\\memory', '\\docs'];
             for (const suffix of problematicSuffixes) {
                 if (normalized.endsWith(suffix)) {
-                    const parent = path.dirname(normalized);
+                    const parent = pathApi.dirname(normalized);
                     this.log('warn', `Detected subdirectory suffix '${suffix}' in path. Normalized to parent: ${parent}`);
                     normalized = parent;
                     break;
@@ -166,47 +200,72 @@ export class PathResolver {
             this.log('info', `Using state directory from PD_STATE_DIR: ${this.stateDir}`);
             return this.stateDir;
         }
+        // If workspaceDir was explicitly provided via constructor, use workspace-based state dir
+        // This ensures tests and programmatic usage don't get polluted by global config
+        if (this.initialized && this.workspaceDir) {
+            const pathApi = getPathApi(this.workspaceDir);
+            this.stateDir = pathApi.join(this.workspaceDir, '.state');
+            this.log('debug', `Using workspace-based state directory: ${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');
+        const workspaceDir = this.getWorkspaceDir();
+        const pathApi = getPathApi(workspaceDir);
+        this.stateDir = pathApi.join(workspaceDir, '.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 workspacePath = getPathApi(workspace);
+        const extensionRoot = PathResolver.extensionRoot || path.resolve(process.cwd(), 'packages', 'openclaw-plugin');
+        const extensionPath = getPathApi(extensionRoot);
+        const memory = workspacePath.join(workspace, 'memory');
+        const extensionSrc = extensionPath.join(extensionRoot, 'src');
+        const extensionDist = extensionPath.join(extensionRoot, 'dist');
+        const evolutionWorker = fs.existsSync(extensionSrc)
+            ? extensionPath.join(extensionSrc, 'service', 'evolution-worker.ts')
+            : extensionPath.join(extensionDist, 'service', 'evolution-worker.js');
         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'),
+            'PROFILE': workspacePath.join(workspace, '.principles', 'PROFILE.json'),
+            'PRINCIPLES': workspacePath.join(workspace, '.principles', 'PRINCIPLES.md'),
+            'THINKING_OS': workspacePath.join(workspace, '.principles', 'THINKING_OS.md'),
+            'KERNEL': workspacePath.join(workspace, '.principles', '00-kernel.md'),
+            'DECISION_POLICY': workspacePath.join(workspace, '.principles', 'DECISION_POLICY.json'),
+            'MODELS_DIR': workspacePath.join(workspace, '.principles', 'models'),
+            'PLAN': workspacePath.join(workspace, 'PLAN.md'),
+            'AGENT_SCORECARD': workspacePath.join(state, 'AGENT_SCORECARD.json'),
+            'PAIN_FLAG': workspacePath.join(state, '.pain_flag'),
+            'EVOLUTION_QUEUE': workspacePath.join(state, 'evolution_queue.json'),
+            'EVOLUTION_DIRECTIVE': workspacePath.join(state, 'evolution_directive.json'),
+            'WORKBOARD': workspacePath.join(state, 'WORKBOARD.json'),
+            'SYSTEM_CAPABILITIES': workspacePath.join(state, 'SYSTEM_CAPABILITIES.json'),
+            'PAIN_SETTINGS': workspacePath.join(state, 'pain_settings.json'),
+            'PAIN_CANDIDATES': workspacePath.join(state, 'pain_candidates.json'),
+            'THINKING_OS_USAGE': workspacePath.join(state, 'thinking_os_usage.json'),
+            'DICTIONARY': workspacePath.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'),
+            'EXTENSION_ROOT': extensionRoot,
+            'EXTENSION_SRC': extensionSrc,
+            'EXTENSION_DIST': extensionDist,
+            'EVOLUTION_WORKER': evolutionWorker,
+            'LOGS': workspacePath.join(memory, 'logs'),
+            'SYSTEM_LOG': workspacePath.join(memory, 'logs', 'SYSTEM.log'),
+            'REFLECTION_LOG': workspacePath.join(memory, 'reflection-log.md'),
+            'USER_CONTEXT': workspacePath.join(memory, 'USER_CONTEXT.md'),
+            'OKR_DIR': workspacePath.join(memory, 'okr'),
+            'CURRENT_FOCUS': workspacePath.join(memory, 'okr', 'CURRENT_FOCUS.md'),
+            'WEEK_STATE': workspacePath.join(memory, 'okr', 'WEEK_STATE.json'),
+            'THINKING_OS_CANDIDATES': workspacePath.join(memory, 'THINKING_OS_CANDIDATES.md'),
+            'EVOLUTION_STREAM': workspacePath.join(memory, 'evolution.jsonl'),
+            'EVOLUTION_LOCK': workspacePath.join(memory, '.locks', 'evolution'),
+            'PRINCIPLE_BLACKLIST': workspacePath.join(state, 'principle_blacklist.json'),
             'MEMORY': memory,
         };
         const resolved = pathMap[key];

package/dist/core/paths.d.ts

@@ -3,22 +3,15 @@
  * 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;
+    LOCKS: string;
 };
 /**
  * Standard File Path Mappings
@@ -40,8 +33,12 @@ export declare const PD_FILES: {
     PAIN_SETTINGS: string;
     PAIN_CANDIDATES: string;
     THINKING_OS_USAGE: string;
+    TRAJECTORY_DB: string;
+    TRAJECTORY_BLOBS_DIR: string;
+    EXPORTS_DIR: string;
     SESSION_DIR: string;
     DICTIONARY: string;
+    PRINCIPLE_BLACKLIST: string;
     PLAN: string;
     MEMORY_MD: string;
     HEARTBEAT: string;
@@ -53,6 +50,8 @@ export declare const PD_FILES: {
     WEEK_STATE: string;
     THINKING_OS_CANDIDATES: string;
     SEMANTIC_PAIN: string;
+    EVOLUTION_STREAM: string;
+    EVOLUTION_LOCK: string;
 };
 /**
  * Resolves a PD file path within a given workspace.