principles-disciple 1.6.0 → 1.7.1

package/dist/core/evolution-reducer.js

@@ -0,0 +1,369 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { withLock } from '../utils/file-lock.js';
+import { PathResolver } from './path-resolver.js';
+import { SystemLogger } from './system-logger.js';
+import { shouldIgnorePainProtocolText } from './dictionary.js';
+import { TrajectoryRegistry } from './trajectory.js';
+const PROBATION_SUCCESS_THRESHOLD = 3;
+const CIRCUIT_BREAKER_THRESHOLD = 3;
+const PROBATION_MAX_AGE_DAYS = 30;
+export class EvolutionReducerImpl {
+    streamPath;
+    lockTargetPath;
+    blacklistPath;
+    workspaceDir;
+    memoryEvents = [];
+    principles = new Map();
+    failureStreak = new Map();
+    lastPromotedAt = null;
+    isReplaying = false;
+    constructor(opts) {
+        this.workspaceDir = opts.workspaceDir;
+        const resolver = new PathResolver({ workspaceDir: opts.workspaceDir });
+        this.streamPath = resolver.resolve('EVOLUTION_STREAM');
+        this.lockTargetPath = resolver.resolve('EVOLUTION_LOCK');
+        this.blacklistPath = resolver.resolve('PRINCIPLE_BLACKLIST');
+        this.ensureDirs();
+        this.loadFromStream();
+        this.sweepExpiredProbation();
+    }
+    emit(event) {
+        this.emitSync(event);
+    }
+    emitSync(event) {
+        withLock(this.lockTargetPath, () => {
+            fs.appendFileSync(this.streamPath, `${JSON.stringify(event)}\n`, 'utf8');
+        }, { lockStaleMs: 15000 });
+        this.applyEvent(event);
+        if (event.type !== 'pain_detected') {
+            try {
+                TrajectoryRegistry.use(this.workspaceDir, (trajectory) => {
+                    trajectory.recordPrincipleEvent({
+                        principleId: 'principleId' in event.data && typeof event.data.principleId === 'string' ? event.data.principleId : null,
+                        eventType: event.type,
+                        payload: event.data,
+                        createdAt: event.ts,
+                    });
+                });
+            }
+            catch {
+                // Keep evolution loop resilient if trajectory storage is unavailable.
+            }
+        }
+        // Performance: sweepExpiredProbation() moved to getProbationPrinciples() for lazy cleanup
+    }
+    getEventLog() {
+        return [...this.memoryEvents];
+    }
+    getCandidatePrinciples() {
+        return this.getByStatus('candidate');
+    }
+    getProbationPrinciples() {
+        // Lazy cleanup: sweep expired probation principles on access
+        this.sweepExpiredProbation();
+        return this.getByStatus('probation');
+    }
+    getActivePrinciples() {
+        return this.getByStatus('active');
+    }
+    getPrincipleById(id) {
+        return this.principles.get(id) ?? null;
+    }
+    promote(principleId, reason = 'manual') {
+        const p = this.principles.get(principleId);
+        if (!p || p.status === 'active' || p.status === 'deprecated')
+            return;
+        const nextStatus = p.status === 'candidate' ? 'probation' : 'active';
+        const event = {
+            ts: new Date().toISOString(),
+            type: 'principle_promoted',
+            data: {
+                principleId,
+                from: p.status,
+                to: nextStatus,
+                reason,
+                successCount: p.validation.successCount,
+            },
+        };
+        this.emitSync(event);
+    }
+    deprecate(principleId, reason) {
+        const p = this.principles.get(principleId);
+        if (!p || p.status === 'deprecated')
+            return;
+        this.emitSync({
+            ts: new Date().toISOString(),
+            type: 'principle_deprecated',
+            data: {
+                principleId,
+                reason,
+                triggeredBy: 'manual',
+            },
+        });
+    }
+    rollbackPrinciple(principleId, reason) {
+        const p = this.principles.get(principleId);
+        if (!p)
+            return;
+        this.emitSync({
+            ts: new Date().toISOString(),
+            type: 'principle_rolled_back',
+            data: {
+                principleId,
+                reason,
+                triggeredBy: 'user_command',
+                blacklistPattern: p.trigger,
+                relatedPainId: p.source.painId,
+            },
+        });
+    }
+    recordProbationFeedback(principleId, success) {
+        const p = this.principles.get(principleId);
+        if (!p || p.status !== 'probation')
+            return;
+        if (success) {
+            p.validation.successCount += 1;
+            p.feedbackScore += 10;
+            if (p.validation.successCount >= PROBATION_SUCCESS_THRESHOLD) {
+                this.promote(principleId, 'auto_threshold');
+            }
+            return;
+        }
+        p.validation.conflictCount += 1;
+        if (p.validation.conflictCount >= 1) {
+            this.deprecate(principleId, 'conflict_detected');
+        }
+    }
+    getStats() {
+        return {
+            candidateCount: this.getCandidatePrinciples().length,
+            probationCount: this.getProbationPrinciples().length,
+            activeCount: this.getActivePrinciples().length,
+            deprecatedCount: this.getByStatus('deprecated').length,
+            lastPromotedAt: this.lastPromotedAt,
+        };
+    }
+    ensureDirs() {
+        fs.mkdirSync(path.dirname(this.streamPath), { recursive: true });
+        fs.mkdirSync(path.dirname(this.lockTargetPath), { recursive: true });
+        fs.mkdirSync(path.dirname(this.blacklistPath), { recursive: true });
+    }
+    loadFromStream() {
+        if (!fs.existsSync(this.streamPath))
+            return;
+        const raw = fs.readFileSync(this.streamPath, 'utf8').trim();
+        if (!raw)
+            return;
+        this.isReplaying = true;
+        for (const line of raw.split('\n')) {
+            try {
+                const event = JSON.parse(line);
+                this.applyEvent(event);
+            }
+            catch (e) {
+                SystemLogger.log(this.workspaceDir, 'EVOLUTION_WARN', `skip malformed event line: ${String(e)}`);
+            }
+        }
+        this.isReplaying = false;
+    }
+    applyEvent(event) {
+        this.memoryEvents.push(event);
+        switch (event.type) {
+            case 'pain_detected':
+                this.updateFailureStreakFromPain(event.data);
+                if (!this.isReplaying) {
+                    this.onPainDetected(event.data, event.ts);
+                }
+                return;
+            case 'candidate_created':
+                this.onCandidateCreated(event.data, event.ts);
+                return;
+            case 'principle_promoted':
+                this.onPrinciplePromoted(event.data, event.ts);
+                return;
+            case 'principle_deprecated':
+                this.onPrincipleDeprecated(event.data, event.ts);
+                return;
+            case 'principle_rolled_back':
+                this.onPrincipleRolledBack(event.data, event.ts);
+                return;
+            case 'circuit_breaker_opened':
+            case 'legacy_import':
+                return;
+            default:
+                return;
+        }
+    }
+    onCandidateCreated(data, ts) {
+        const existing = this.principles.get(data.principleId);
+        if (existing) {
+            existing.status = 'candidate';
+            return;
+        }
+        const principle = {
+            id: data.principleId,
+            version: 1,
+            text: `When ${data.trigger}, then ${data.action}.`,
+            source: {
+                painId: data.painId,
+                painType: 'tool_failure',
+                timestamp: ts,
+            },
+            trigger: data.trigger,
+            action: data.action,
+            contextTags: [],
+            validation: { successCount: 0, conflictCount: 0 },
+            status: 'candidate',
+            feedbackScore: 0,
+            usageCount: 0,
+            createdAt: ts,
+        };
+        this.principles.set(principle.id, principle);
+    }
+    onPrinciplePromoted(data, ts) {
+        const p = this.principles.get(data.principleId);
+        if (!p)
+            return;
+        p.status = data.to;
+        if (data.to === 'active') {
+            p.activatedAt = ts;
+        }
+        this.lastPromotedAt = ts;
+    }
+    onPrincipleDeprecated(data, ts) {
+        const p = this.principles.get(data.principleId);
+        if (!p)
+            return;
+        p.status = 'deprecated';
+        p.deprecatedAt = ts;
+    }
+    onPrincipleRolledBack(data, ts) {
+        const p = this.principles.get(data.principleId);
+        if (p) {
+            p.status = 'deprecated';
+            p.deprecatedAt = ts;
+        }
+        this.persistBlacklist({
+            painId: data.relatedPainId,
+            pattern: data.blacklistPattern,
+            reason: data.reason,
+            rolledBackAt: ts,
+        });
+    }
+    onPainDetected(data, eventTs) {
+        const trigger = String(data.reason ?? data.source ?? 'unknown trigger');
+        const action = `Prevent recurrence for: ${String(data.source ?? 'unknown')}`;
+        // Defense in depth: protocol/system tokens must never become principles,
+        // even if a pain_detected event is emitted from a new callsite in the future.
+        if (shouldIgnorePainProtocolText(trigger)) {
+            return;
+        }
+        if (this.isBlacklisted(data.painId, trigger)) {
+            return;
+        }
+        const principleId = this.nextPrincipleId();
+        const principle = {
+            id: principleId,
+            version: 1,
+            text: `When ${trigger}, then ${action}.`,
+            source: {
+                painId: data.painId,
+                painType: data.painType,
+                timestamp: eventTs,
+            },
+            trigger,
+            action,
+            contextTags: [data.source],
+            validation: { successCount: 0, conflictCount: 0 },
+            status: 'candidate',
+            feedbackScore: 0,
+            usageCount: 0,
+            createdAt: eventTs,
+        };
+        this.principles.set(principleId, principle);
+        this.emitSync({
+            ts: new Date().toISOString(),
+            type: 'candidate_created',
+            data: {
+                painId: principle.source.painId,
+                principleId,
+                trigger,
+                action,
+                status: 'candidate',
+            },
+        });
+        this.promote(principleId, 'auto_from_pain');
+        if (data.painType === 'subagent_error') {
+            const key = String(data.taskId ?? data.source ?? 'subagent');
+            const next = this.failureStreak.get(key) ?? 0;
+            if (next >= CIRCUIT_BREAKER_THRESHOLD) {
+                const nextRetryAt = new Date(Date.now() + 15 * 60 * 1000).toISOString();
+                this.emitSync({
+                    ts: new Date().toISOString(),
+                    type: 'circuit_breaker_opened',
+                    data: {
+                        taskId: key,
+                        painId: principle.source.painId,
+                        failCount: next,
+                        reason: 'Max retries exceeded',
+                        requireHuman: true,
+                        nextRetryAt,
+                    },
+                });
+            }
+        }
+    }
+    updateFailureStreakFromPain(data) {
+        if (data.painType !== 'subagent_error')
+            return;
+        const key = String(data.taskId ?? data.source ?? 'subagent');
+        const next = (this.failureStreak.get(key) ?? 0) + 1;
+        this.failureStreak.set(key, next);
+    }
+    nextPrincipleId() {
+        const ids = [...this.principles.keys()]
+            .map((id) => Number(id.replace(/^P_/, '')))
+            .filter((n) => Number.isFinite(n));
+        const next = (ids.length ? Math.max(...ids) : 0) + 1;
+        return `P_${String(next).padStart(3, '0')}`;
+    }
+    getByStatus(status) {
+        return [...this.principles.values()].filter((p) => p.status === status);
+    }
+    sweepExpiredProbation() {
+        const now = Date.now();
+        const maxAgeMs = PROBATION_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+        // Use getByStatus directly to avoid infinite recursion with getProbationPrinciples()
+        for (const p of this.getByStatus('probation')) {
+            const age = now - new Date(p.createdAt).getTime();
+            if (age > maxAgeMs) {
+                this.deprecate(p.id, 'probation_expired');
+            }
+        }
+    }
+    persistBlacklist(entry) {
+        const list = this.loadBlacklist();
+        list.push(entry);
+        fs.writeFileSync(this.blacklistPath, JSON.stringify(list, null, 2), 'utf8');
+    }
+    loadBlacklist() {
+        if (!fs.existsSync(this.blacklistPath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.blacklistPath, 'utf8'));
+        }
+        catch (e) {
+            SystemLogger.log(this.workspaceDir, 'EVOLUTION_WARN', `failed to parse blacklist: ${String(e)}`);
+            return [];
+        }
+    }
+    isBlacklisted(painId, trigger) {
+        return this.loadBlacklist().some((entry) => (entry.painId && entry.painId === painId) ||
+            (entry.pattern && trigger.includes(entry.pattern)));
+    }
+}
+export function stableContentHash(input) {
+    return crypto.createHash('sha1').update(input).digest('hex');
+}

package/dist/core/evolution-types.d.ts

@@ -124,3 +124,106 @@ export interface TierPromotionEvent {
     timestamp: string;
     newPermissions: TierPermissions;
 }
+export type PrincipleStatus = 'candidate' | 'probation' | 'active' | 'deprecated';
+export interface Principle {
+    id: string;
+    version: number;
+    text: string;
+    source: {
+        painId: string;
+        painType: 'tool_failure' | 'subagent_error' | 'user_frustration';
+        timestamp: string;
+    };
+    trigger: string;
+    action: string;
+    guardrails?: string[];
+    contextTags: string[];
+    validation: {
+        successCount: number;
+        conflictCount: number;
+    };
+    status: PrincipleStatus;
+    feedbackScore: number;
+    usageCount: number;
+    createdAt: string;
+    activatedAt?: string;
+    deprecatedAt?: string;
+}
+export type EvolutionLoopEventType = 'pain_detected' | 'candidate_created' | 'principle_promoted' | 'principle_deprecated' | 'principle_rolled_back' | 'circuit_breaker_opened' | 'legacy_import';
+export interface PainDetectedData {
+    painId: string;
+    painType: 'tool_failure' | 'subagent_error' | 'user_frustration';
+    source: string;
+    reason: string;
+    score?: number;
+    sessionId?: string;
+    taskId?: string;
+}
+export interface CandidateCreatedData {
+    painId: string;
+    principleId: string;
+    trigger: string;
+    action: string;
+    status: 'candidate';
+}
+export interface PrinciplePromotedData {
+    principleId: string;
+    from: 'candidate' | 'probation';
+    to: 'probation' | 'active';
+    reason: string;
+    successCount?: number;
+}
+export interface PrincipleDeprecatedData {
+    principleId: string;
+    reason: string;
+    triggeredBy: 'auto' | 'manual';
+}
+export interface PrincipleRolledBackData {
+    principleId: string;
+    reason: string;
+    triggeredBy: 'user_command' | 'auto_conflict';
+    blacklistPattern?: string;
+    relatedPainId?: string;
+}
+export interface CircuitBreakerOpenedData {
+    taskId: string;
+    painId: string;
+    failCount: number;
+    reason: string;
+    requireHuman: boolean;
+    nextRetryAt?: string;
+}
+export interface LegacyImportData {
+    sourceFile: string;
+    content: string;
+    contentHash?: string;
+}
+export type EvolutionLoopEvent = {
+    ts: string;
+    type: 'pain_detected';
+    data: PainDetectedData;
+} | {
+    ts: string;
+    type: 'candidate_created';
+    data: CandidateCreatedData;
+} | {
+    ts: string;
+    type: 'principle_promoted';
+    data: PrinciplePromotedData;
+} | {
+    ts: string;
+    type: 'principle_deprecated';
+    data: PrincipleDeprecatedData;
+} | {
+    ts: string;
+    type: 'principle_rolled_back';
+    data: PrincipleRolledBackData;
+} | {
+    ts: string;
+    type: 'circuit_breaker_opened';
+    data: CircuitBreakerOpenedData;
+} | {
+    ts: string;
+    type: 'legacy_import';
+    data: LegacyImportData;
+};

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)) {
@@ -77,7 +92,9 @@ export class PathResolver {
         if (!extensionRootPath || !extensionRootPath.trim()) {
             return;
         }
-        PathResolver.extensionRoot = path.resolve(extensionRootPath.trim());
+        const trimmed = extensionRootPath.trim();
+        const pathApi = getPathApi(trimmed);
+        PathResolver.extensionRoot = pathApi.normalize(trimmed);
     }
     static getExtensionRoot() {
         return PathResolver.extensionRoot;
@@ -86,7 +103,13 @@ export class PathResolver {
         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) {
@@ -132,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;
@@ -176,57 +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 extensionSrc = path.join(extensionRoot, 'src');
-        const extensionDist = path.join(extensionRoot, 'dist');
+        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)
-            ? path.join(extensionSrc, 'service', 'evolution-worker.ts')
-            : path.join(extensionDist, 'service', 'evolution-worker.js');
+            ? 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,
             'EXTENSION_ROOT': extensionRoot,
             'EXTENSION_SRC': extensionSrc,
             'EXTENSION_DIST': extensionDist,
             'EVOLUTION_WORKER': evolutionWorker,
-            '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'),
+            '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.