principles-disciple 1.5.4 → 1.6.0

package/dist/i18n/commands.js

@@ -15,48 +15,60 @@ export function normalizeLanguage(lang) {
 }
 export const commandDescriptions = {
     'pd-init': {
-        zh: '初始化战略访谈和OKR',
-        en: 'Initialize strategy interview and OKRs'
+        zh: '初始化工作区（生成 PRINCIPLES.md、THINKING_OS.md 等）',
+        en: 'Initialize workspace (generate PRINCIPLES.md, THINKING_OS.md, etc.)'
     },
     'pd-okr': {
-        zh: '目标与关键结果管理',
-        en: 'Manage OKRs and align goals'
+        zh: '管理 OKR 目标与关键结果',
+        en: 'Manage OKR goals and key results'
     },
     'pd-bootstrap': {
-        zh: '环境工具扫描与升级',
-        en: 'Scan and upgrade environment tools'
+        zh: '扫描环境工具并建议升级',
+        en: 'Scan environment tools and suggest upgrades'
     },
     'pd-research': {
-        zh: '发起工具升级研究',
-        en: 'Research tool upgrades'
+        zh: '研究工具升级方案',
+        en: 'Research tool upgrade solutions'
     },
     'pd-thinking': {
-        zh: '管理思维模型与候选方案',
-        en: 'Manage Thinking OS mental models'
+        zh: '管理思维模型 [status|propose|audit]',
+        en: 'Manage Thinking OS [status|propose|audit]'
     },
     'pd-evolve': {
-        zh: '执行完整进化循环',
-        en: 'Run full evolution loop'
+        zh: '执行进化循环处理 Pain 信号',
+        en: 'Run evolution loop to process Pain signals'
     },
     'pd-daily': {
         zh: '配置并发送进化日报',
-        en: 'Configure and send daily report'
+        en: 'Configure and send daily evolution report'
     },
     'pd-grooming': {
-        zh: '工作区数字大扫除',
+        zh: '工作区清理与大扫除',
         en: 'Workspace cleanup and grooming'
     },
     'pd-trust': {
-        zh: '查看信任积分与安全等级',
-        en: 'View trust score and security stage'
+        zh: '查看信任分数和权限等级 (1-4)',
+        en: 'View trust score and permission stage (1-4)'
     },
     'pd-help': {
-        zh: '获取交互式命令引导',
-        en: 'Get interactive command guidance'
+        zh: '显示所有命令和使用指南',
+        en: 'Show all commands and usage guide'
     },
     'pd-status': {
-        zh: '查看数字神经系统状态（GFI和痛苦词典）',
-        en: 'View Digital Nerve System status (GFI and Pain Dictionary)'
+        zh: '查看系统状态（GFI、Pain 词典）',
+        en: 'View system status (GFI, Pain dictionary)'
+    },
+    'pd-context': {
+        zh: '控制上下文注入 [status|thinking|trust|reflection|focus|preset] - 输入 /pd-context help 查看详情',
+        en: 'Control context injection [status|thinking|trust|reflection|focus|preset] - Type /pd-context help for details'
+    },
+    'pd-focus': {
+        zh: '管理 CURRENT_FOCUS.md [status|history|compress|rollback] - 查看/压缩/回滚焦点文件',
+        en: 'Manage CURRENT_FOCUS.md [status|history|compress|rollback] - View/compress/rollback focus file'
+    },
+    'pd-rollback': {
+        zh: '回滚情绪事件惩罚 <event-id>|last',
+        en: 'Rollback empathy event penalty <event-id>|last'
     }
 };
 /**

package/dist/index.js

@@ -5,18 +5,23 @@ import { handleAfterToolCall } from './hooks/pain.js';
 import { handleBeforeReset, handleBeforeCompaction, handleAfterCompaction } from './hooks/lifecycle.js';
 import { handleLlmOutput } from './hooks/llm.js';
 import { handleSubagentEnded } from './hooks/subagent.js';
+import { handleBeforeMessageWrite } from './hooks/message-sanitize.js';
 import { handleInitStrategy, handleManageOkr } from './commands/strategy.js';
 import { handleBootstrapTools, handleResearchTools } from './commands/capabilities.js';
 import { handleThinkingOs } from './commands/thinking-os.js';
 import { handleEvolveTask } from './commands/evolver.js';
 import { handleTrustCommand } from './commands/trust.js';
 import { handlePainCommand } from './commands/pain.js';
+import { handleContextCommand } from './commands/context.js';
+import { handleFocusCommand } from './commands/focus.js';
+import { handleRollbackCommand } from './commands/rollback.js';
 import { EvolutionWorkerService } from './service/evolution-worker.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
 import { SystemLogger } from './core/system-logger.js';
 import { deepReflectTool } from './tools/deep-reflect.js';
 import { agentSpawnTool } from './tools/agent-spawn.js';
+import { PathResolver } from './core/path-resolver.js';
 // Track initialization to avoid repeated calls
 let workspaceInitialized = false;
 const plugin = {
@@ -24,6 +29,7 @@ const plugin = {
     description: "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
     register(api) {
         api.logger.info("Principles Disciple Plugin registered.");
+        PathResolver.setExtensionRoot(api.rootDir);
         const language = api.pluginConfig?.language || 'en';
         // ── Hook: Prompt Building ──
         api.on('before_prompt_build', async (event, ctx) => {
@@ -75,6 +81,15 @@ const plugin = {
                 api.logger.error(`[PD] Error in llm_output: ${String(err)}`);
             }
         });
+        // ── Hook: Message Sanitization ──
+        api.on('before_message_write', (event) => {
+            try {
+                return handleBeforeMessageWrite(event);
+            }
+            catch (err) {
+                api.logger.error(`[PD] Error in before_message_write: ${String(err)}`);
+            }
+        });
         // ── Hook: Subagent Loop Closure ──
         api.on('subagent_spawning', (_event, _ctx) => {
             // No-op for now, just to satisfy the interface expected by tests.
@@ -83,7 +98,7 @@ const plugin = {
         api.on('subagent_ended', (event, ctx) => {
             try {
                 const workspaceDir = api.resolvePath('.');
-                handleSubagentEnded(event, { ...ctx, workspaceDir });
+                handleSubagentEnded(event, { ...ctx, workspaceDir, api });
             }
             catch (err) {
                 api.logger.error(`[PD] Error in subagent_ended: ${String(err)}`);
@@ -165,9 +180,120 @@ const plugin = {
             name: "pd-help",
             description: getCommandDescription('pd-help', language),
             handler: (_ctx) => {
-                return { text: language === 'zh'
-                        ? "我是你的麻辣导师。你可以输入 '执行 pd-mentor 技能' 来获取手把手的流程引导，或者直接问我关于 DNS、Trust Engine 或进化循环的深度问题。记住：痛是进化的燃料，而我是点火的人。"
-                        : "I'm your Spicy Mentor. You can execute the 'pd-mentor' skill for step-by-step guidance, or ask me directly about DNS, Trust Engine, or the evolution loop. Remember: Pain is the fuel of evolution, and I'm the one who lights the fire." };
+                if (language === 'zh') {
+                    return { text: `
+📖 **Principles Disciple 命令大全**
+
+## 🚀 快速开始
+| 命令 | 用途 | 使用时机 |
+|------|------|----------|
+| \`/pd-init\` | 初始化工作区 | 新项目开始时 |
+| \`/pd-bootstrap\` | 环境工具扫描 | 缺少开发工具时 |
+
+## 📊 状态查询
+| 命令 | 用途 | 使用时机 |
+|------|------|----------|
+| \`/pd-status\` | 查看进化状态 | 想了解当前 GFI 和 Pain 情况 |
+| \`/pd-trust\` | 查看信任分数 | 想知道自己的权限等级 |
+| \`/pd-focus\` | 焦点文件管理 | 查看/压缩/回滚历史版本 |
+
+## ⚙️ 配置管理
+| 命令 | 用途 | 使用时机 |
+|------|------|----------|
+| \`/pd-context\` | 控制上下文注入 | 想减少/增加注入内容 |
+| \`/pd-okr\` | OKR 目标管理 | 设置战略目标 |
+
+## 🧠 进化相关
+| 命令 | 用途 | 使用时机 |
+|------|------|----------|
+| \`/pd-evolve\` | 执行进化循环 | 有 Pain 需要处理时 |
+| \`/pd-thinking\` | 思维模型管理 | 更新 Thinking OS |
+| \`/pd-daily\` | 进化日报 | 每日回顾时 |
+| \`/pd-grooming\` | 工作区大扫除 | 定期清理 |
+
+## 💡 常用命令示例
+
+**减少 token 消耗：**
+\`\`\`
+/pd-context minimal
+\`\`\`
+
+**恢复完整上下文：**
+\`\`\`
+/pd-context full
+\`\`\`
+
+**查看当前配置：**
+\`\`\`
+/pd-context status
+\`\`\`
+
+**查看信任分数：**
+\`\`\`
+/pd-trust
+\`\`\`
+
+---
+🔍 输入任意命令后加 \`help\` 可查看详细帮助，如 \`/pd-context help\`
+`.trim() };
+                }
+                else {
+                    return { text: `
+📖 **Principles Disciple Command Reference**
+
+## 🚀 Quick Start
+| Command | Purpose | When to Use |
+|---------|---------|-------------|
+| \`/pd-init\` | Initialize workspace | Starting a new project |
+| \`/pd-bootstrap\` | Scan environment tools | Missing dev tools |
+
+## 📊 Status Query
+| Command | Purpose | When to Use |
+|---------|---------|-------------|
+| \`/pd-status\` | View evolution status | Check GFI and Pain status |
+| \`/pd-trust\` | View trust score | Check your permission level |
+| \`/pd-focus\` | Focus file management | View/compress/rollback history |
+
+## ⚙️ Configuration
+| Command | Purpose | When to Use |
+|---------|---------|-------------|
+| \`/pd-context\` | Control context injection | Reduce/increase injected content |
+| \`/pd-okr\` | OKR goal management | Set strategic goals |
+
+## 🧠 Evolution
+| Command | Purpose | When to Use |
+|---------|---------|-------------|
+| \`/pd-evolve\` | Run evolution loop | Process Pain signals |
+| \`/pd-thinking\` | Mental model management | Update Thinking OS |
+| \`/pd-daily\` | Evolution report | Daily review |
+| \`/pd-grooming\` | Workspace cleanup | Periodic cleanup |
+
+## 💡 Common Examples
+
+**Reduce token usage:**
+\`\`\`
+/pd-context minimal
+\`\`\`
+
+**Restore full context:**
+\`\`\`
+/pd-context full
+\`\`\`
+
+**View current config:**
+\`\`\`
+/pd-context status
+\`\`\`
+
+**Check trust score:**
+\`\`\`
+/pd-trust
+\`\`\`
+
+---
+🔍 Add \`help\` after any command for details, e.g., \`/pd-context help\`
+`.trim() };
+                }
             }
         });
         api.registerCommand({
@@ -196,6 +322,57 @@ const plugin = {
                 }
             }
         });
+        api.registerCommand({
+            name: "pd-context",
+            description: getCommandDescription('pd-context', language),
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleContextCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-context failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "命令执行失败，请检查日志。" : "Command failed. Check logs." };
+                }
+            }
+        });
+        api.registerCommand({
+            name: "pd-focus",
+            description: getCommandDescription('pd-focus', language),
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleFocusCommand(ctx, api);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-focus failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "命令执行失败，请检查日志。" : "Command failed. Check logs." };
+                }
+            }
+        });
+        api.registerCommand({
+            name: "pd-rollback",
+            description: getCommandDescription('pd-rollback', language),
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleRollbackCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-rollback failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "命令执行失败，请检查日志。" : "Command failed. Check logs." };
+                }
+            }
+        });
         // ── Tools ──
         api.registerTool(deepReflectTool);
         api.registerTool(agentSpawnTool);

package/dist/service/empathy-observer-manager.d.ts

@@ -0,0 +1,42 @@
+import type { PluginLogger } from '../openclaw-sdk.js';
+export interface EmpathyObserverApi {
+    config?: {
+        empathy_engine?: {
+            enabled?: boolean;
+        };
+    };
+    runtime: {
+        subagent: {
+            run: (params: {
+                sessionKey: string;
+                message: string;
+                lane?: string;
+                deliver?: boolean;
+                idempotencyKey?: string;
+            }) => Promise<unknown>;
+            getSessionMessages: (params: {
+                sessionKey: string;
+                limit?: number;
+            }) => Promise<{
+                messages: unknown[];
+                assistantTexts?: string[];
+            }>;
+        };
+    };
+    logger: PluginLogger;
+}
+export declare class EmpathyObserverManager {
+    private static instance;
+    private sessionLocks;
+    private constructor();
+    static getInstance(): EmpathyObserverManager;
+    shouldTrigger(api: EmpathyObserverApi | null | undefined, sessionId: string): boolean;
+    spawn(api: EmpathyObserverApi | null | undefined, sessionId: string, userMessage: string): Promise<string | null>;
+    reap(api: EmpathyObserverApi | null | undefined, targetSessionKey: string, workspaceDir: string): Promise<void>;
+    private isObserverSession;
+    private extractParentSessionId;
+    private parseJsonPayload;
+    private extractAssistantText;
+    private scoreFromSeverity;
+}
+export declare const empathyObserverManager: EmpathyObserverManager;

package/dist/service/empathy-observer-manager.js

@@ -0,0 +1,147 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { trackFriction } from '../core/session-tracker.js';
+const OBSERVER_SESSION_PREFIX = 'empathy_obs:';
+export class EmpathyObserverManager {
+    static instance;
+    sessionLocks = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!EmpathyObserverManager.instance) {
+            EmpathyObserverManager.instance = new EmpathyObserverManager();
+        }
+        return EmpathyObserverManager.instance;
+    }
+    shouldTrigger(api, sessionId) {
+        if (!api || !sessionId)
+            return false;
+        const enabled = api.config?.empathy_engine?.enabled !== false;
+        if (!enabled)
+            return false;
+        return !this.sessionLocks.has(sessionId);
+    }
+    async spawn(api, sessionId, userMessage) {
+        if (!api)
+            return null;
+        if (!this.shouldTrigger(api, sessionId))
+            return null;
+        if (!userMessage?.trim())
+            return null;
+        const timestamp = Date.now();
+        const sessionKey = `${OBSERVER_SESSION_PREFIX}${sessionId}:${timestamp}`;
+        this.sessionLocks.set(sessionId, sessionKey);
+        const prompt = [
+            'You are an empathy observer.',
+            'Analyze ONLY the user message and return strict JSON (no markdown):',
+            '{"damageDetected": boolean, "severity": "mild|moderate|severe", "confidence": number, "reason": string}',
+            `User message: ${JSON.stringify(userMessage.trim())}`,
+        ].join('\n');
+        try {
+            await api.runtime.subagent.run({
+                sessionKey,
+                message: prompt,
+                lane: 'subagent',
+                deliver: false,
+                idempotencyKey: `${sessionId}:${timestamp}`,
+            });
+            api.logger.info(`[PD:EmpathyObserver] Spawned observer ${sessionKey}`);
+            return sessionKey;
+        }
+        catch (error) {
+            this.sessionLocks.delete(sessionId);
+            api.logger.warn(`[PD:EmpathyObserver] Failed to spawn observer for ${sessionId}: ${String(error)}`);
+            return null;
+        }
+    }
+    async reap(api, targetSessionKey, workspaceDir) {
+        if (!api || !workspaceDir || !this.isObserverSession(targetSessionKey))
+            return;
+        const sessionId = this.extractParentSessionId(targetSessionKey);
+        const unlock = () => {
+            if (sessionId && this.sessionLocks.get(sessionId) === targetSessionKey) {
+                this.sessionLocks.delete(sessionId);
+            }
+        };
+        try {
+            const messages = await api.runtime.subagent.getSessionMessages({
+                sessionKey: targetSessionKey,
+                limit: 20,
+            });
+            const rawText = this.extractAssistantText(messages.messages, messages.assistantTexts);
+            const parsed = this.parseJsonPayload(rawText, api.logger);
+            if (parsed?.damageDetected && sessionId) {
+                const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
+                const score = this.scoreFromSeverity(parsed.severity, wctx.config);
+                trackFriction(sessionId, score, `observer_empathy_${parsed.severity || 'mild'}`, workspaceDir);
+                api.logger.info(`[PD:EmpathyObserver] Applied GFI +${score} for ${sessionId}`);
+            }
+        }
+        catch (error) {
+            api.logger.warn(`[PD:EmpathyObserver] Failed to reap ${targetSessionKey}: ${String(error)}`);
+        }
+        finally {
+            unlock();
+        }
+    }
+    isObserverSession(sessionKey) {
+        return typeof sessionKey === 'string' && sessionKey.startsWith(OBSERVER_SESSION_PREFIX);
+    }
+    extractParentSessionId(sessionKey) {
+        if (!this.isObserverSession(sessionKey))
+            return null;
+        const rest = sessionKey.slice(OBSERVER_SESSION_PREFIX.length);
+        const marker = rest.lastIndexOf(':');
+        if (marker <= 0)
+            return null;
+        return rest.slice(0, marker);
+    }
+    parseJsonPayload(rawText, logger) {
+        if (!rawText?.trim())
+            return null;
+        try {
+            return JSON.parse(rawText.trim());
+        }
+        catch {
+            const match = rawText.match(/\{[\s\S]*\}/);
+            if (!match) {
+                logger?.warn('[PD:EmpathyObserver] Observer payload is not valid JSON, skipping.');
+                return null;
+            }
+            try {
+                return JSON.parse(match[0]);
+            }
+            catch {
+                logger?.warn('[PD:EmpathyObserver] Failed to parse observer JSON payload, skipping.');
+                return null;
+            }
+        }
+    }
+    extractAssistantText(messages, assistantTexts) {
+        if (assistantTexts && assistantTexts.length > 0) {
+            return assistantTexts[assistantTexts.length - 1] || '';
+        }
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg?.role !== 'assistant')
+                continue;
+            if (typeof msg.content === 'string')
+                return msg.content;
+            if (Array.isArray(msg.content)) {
+                const txt = msg.content
+                    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+                    .map((part) => part.text)
+                    .join('\n');
+                if (txt)
+                    return txt;
+            }
+        }
+        return '';
+    }
+    scoreFromSeverity(severity, config) {
+        if (severity === 'severe')
+            return Number(config.get('empathy_engine.penalties.severe') ?? 40);
+        if (severity === 'moderate')
+            return Number(config.get('empathy_engine.penalties.moderate') ?? 25);
+        return Number(config.get('empathy_engine.penalties.mild') ?? 10);
+    }
+}
+export const empathyObserverManager = EmpathyObserverManager.getInstance();

package/dist/service/evolution-worker.d.ts

@@ -1,6 +1,7 @@
 import type { OpenClawPluginServiceContext, OpenClawPluginApi } from '../openclaw-sdk.js';
 export interface EvolutionQueueItem {
     id: string;
+    task?: string;
     score: number;
     source: string;
     reason: string;

package/dist/service/evolution-worker.js

@@ -89,13 +89,15 @@ function processEvolutionQueue(wctx, logger, eventLog) {
         if (pendingTasks.length > 0) {
             const directivePath = wctx.resolve('EVOLUTION_DIRECTIVE');
             const highestScoreTask = pendingTasks.sort((a, b) => b.score - a.score)[0];
+            const taskDescription = `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
+                `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`;
             const directive = {
                 active: true,
-                task: `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
-                    `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`,
+                task: taskDescription,
                 timestamp: new Date().toISOString()
             };
             fs.writeFileSync(directivePath, JSON.stringify(directive, null, 2), 'utf8');
+            highestScoreTask.task = taskDescription;
             highestScoreTask.status = 'in_progress';
             queueChanged = true;
             if (eventLog) {

package/dist/tools/deep-reflect.js

@@ -1,9 +1,81 @@
 import { Type } from '@sinclair/typebox';
 import { randomUUID } from 'node:crypto';
 import * as fs from 'fs';
+import * as path from 'node:path';
 import { EventLogService } from '../core/event-log.js';
 import { buildCritiquePromptV2 } from './critique-prompt.js';
 import { resolvePdPath } from '../core/paths.js';
+import { reflectionLogRetentionDays } from '../types.js';
+/**
+ * Write reflection result to reflection-log.md
+ * Uses atomic write (temp file + rename) to prevent race conditions
+ */
+function writeToReflectionLog(workspaceDir, context, insights, modelId, depth) {
+    const reflectionLogPath = resolvePdPath(workspaceDir, 'REFLECTION_LOG');
+    const memoryDir = path.dirname(reflectionLogPath);
+    // Ensure memory directory exists
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    const timestamp = new Date().toISOString();
+    const entry = `
+---
+## Reflection at ${timestamp}
+**Model**: ${modelId || 'auto-select'}
+**Depth**: ${depth || 2}
+
+### Context
+${context.substring(0, 500)}${context.length > 500 ? '...' : ''}
+
+### Insights
+${insights}
+
+`;
+    const header = `# Reflection Log\n\n> Auto-generated by Deep Reflection Tool\n> Retention: ${reflectionLogRetentionDays} days\n`;
+    // Read existing content
+    let existingContent = '';
+    if (fs.existsSync(reflectionLogPath)) {
+        existingContent = fs.readFileSync(reflectionLogPath, 'utf8');
+    }
+    const newContent = header + entry + existingContent.replace(header, '');
+    // Atomic write: write to temp file first, then rename
+    const tempPath = `${reflectionLogPath}.tmp`;
+    fs.writeFileSync(tempPath, newContent, 'utf8');
+    fs.renameSync(tempPath, reflectionLogPath);
+}
+/**
+ * Clean up reflection log entries older than retention period
+ */
+function cleanupReflectionLog(workspaceDir) {
+    const reflectionLogPath = resolvePdPath(workspaceDir, 'REFLECTION_LOG');
+    if (!fs.existsSync(reflectionLogPath))
+        return;
+    const content = fs.readFileSync(reflectionLogPath, 'utf8');
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - reflectionLogRetentionDays);
+    // Use more precise regex to match ISO timestamp
+    // Pattern: ---\n## Reflection at 2024-01-15T10:30:00
+    const entryPattern = /---\n## Reflection at (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/g;
+    const parts = content.split(entryPattern);
+    // parts[0] = header, then alternates: timestamp, content, timestamp, content...
+    const header = parts[0];
+    const validEntries = [];
+    for (let i = 1; i < parts.length; i += 2) {
+        const timestamp = parts[i];
+        const entryContent = parts[i + 1] || '';
+        const entryDate = new Date(timestamp);
+        if (entryDate >= cutoffDate) {
+            validEntries.push(`---\n## Reflection at ${timestamp}${entryContent}`);
+        }
+    }
+    if (validEntries.length < (parts.length - 1) / 2) {
+        const newContent = header + validEntries.join('');
+        // Atomic write
+        const tempPath = `${reflectionLogPath}.tmp`;
+        fs.writeFileSync(tempPath, newContent, 'utf8');
+        fs.renameSync(tempPath, reflectionLogPath);
+    }
+}
 const DEFAULT_CONFIG = {
     enabled: true,
     mode: 'auto',
@@ -130,6 +202,14 @@ export const deepReflectTool = {
                         timeout: false
                     });
                 }
+                // Write to reflection log and cleanup old entries
+                try {
+                    writeToReflectionLog(effectiveWorkspaceDir, context, insights, model_id, depth);
+                    cleanupReflectionLog(effectiveWorkspaceDir);
+                }
+                catch (logErr) {
+                    safeLog(api, 'warn', `[DeepReflect] Failed to write reflection log: ${String(logErr)}`);
+                }
                 return `
 # 💎 Deep Reflection Insights
 ---