principles-disciple 1.80.0 → 1.82.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.80.0",
+  "version": "1.82.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.80.0",
+  "version": "1.82.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/commands/strategy.ts

@@ -19,21 +19,3 @@ export function handleInitStrategy(ctx: PluginCommandContext): PluginCommandResu
       `Then update \`${userContextPath}\` with key user preferences discovered.`,
   };
 }
-
-export function handleManageOkr(ctx: PluginCommandContext): PluginCommandResult {
-  const workspaceDir = resolvePluginCommandWorkspaceDir(ctx, 'strategy:manageOkr');
-  const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
-
-  const focusPath = wctx.resolve('CURRENT_FOCUS').replace(workspaceDir, '').replace(/^\/+/, '');
-  const weekStatePath = wctx.resolve('WEEK_STATE').replace(workspaceDir, '').replace(/^\/+/, '');
-
-  return {
-    text:
-      `📊 **OKR Management**\n\n` +
-      `The Agent will analyze recent work and align sub-agent objectives.\n\n` +
-      `**Instructions for Agent:** Read \`${focusPath}\` and \`${weekStatePath}\`. ` +
-      `Compare them against recent session history. ` +
-      `Update OKRs as needed and output a brief alignment report. ` +
-      `If OKRs are stale (>7 days), prompt the user for a re-alignment conversation.`,
-  };
-}

package/src/i18n/commands.ts

@@ -21,10 +21,6 @@ export const commandDescriptions: Record<string, Record<SupportedLanguage, strin
     zh: '初始化工作区（生成 PRINCIPLES.md、THINKING_OS.md 等）',
     en: 'Initialize workspace (generate PRINCIPLES.md, THINKING_OS.md, etc.)'
   },
-  'pd-okr': {
-    zh: '管理 OKR 目标与关键结果',
-    en: 'Manage OKR goals and key results'
-  },
   'pd-bootstrap': {
     zh: '扫描环境工具并建议升级',
     en: 'Scan environment tools and suggest upgrades'
@@ -37,14 +33,6 @@ export const commandDescriptions: Record<string, Record<SupportedLanguage, strin
     zh: '管理思维模型 [status|propose|audit]（默认关闭，/pd-context thinking on 开启）',
     en: 'Manage Thinking OS [status|propose|audit] (off by default, enable via /pd-context thinking on)'
   },
-  'pd-daily': {
-    zh: '配置并发送进化日报',
-    en: 'Configure and send daily evolution report'
-  },
-  'pd-grooming': {
-    zh: '工作区清理与大扫除',
-    en: 'Workspace cleanup and grooming'
-  },
   'pd-help': {
     zh: '显示所有命令和使用指南',
     en: 'Show all commands and usage guide'

package/src/index.ts

@@ -32,7 +32,7 @@ import { handleBeforeReset, handleBeforeCompaction, handleAfterCompaction } from
 import { handleLlmOutput } from './hooks/llm.js';
 import { handleSubagentEnded } from './hooks/subagent.js';
 import * as TrajectoryCollector from './hooks/trajectory-collector.js';
-import { handleInitStrategy, handleManageOkr } from './commands/strategy.js';
+import { handleInitStrategy } from './commands/strategy.js';
 import { handleBootstrapTools, handleResearchTools } from './commands/capabilities.js';
 import { handleThinkingOs } from './commands/thinking-os.js';
 import { handlePainCommand, handlePainReportCommand } from './commands/pain.js';
@@ -49,6 +49,7 @@ import { handleExportCommand } from './commands/export.js';
 import { handleSamplesCommand } from './commands/samples.js';
 import { handleWorkflowDebugCommand } from './commands/workflow-debug.js';
 import { EvolutionWorkerService } from './service/evolution-worker.js';
+import { CorrectionObserverService } from './service/correction-observer-service.js';
 import { TrajectoryService } from './service/trajectory-service.js';
 import { PDTaskService } from './core/pd-task-service.js';
 import { CentralSyncService } from './service/central-sync-service.js';
@@ -168,6 +169,30 @@ export function shouldStartEvolutionWorker(
   return { shouldStart: false, flagSource: flag.source, disabledInfo };
 }
 
+export interface CorrectionObserverGateResult {
+  shouldStart: boolean;
+  flagSource: string;
+  disabledInfo: string | null;
+}
+
+export function shouldStartCorrectionObserver(
+  workspaceDir: string,
+  logger: { info?: (msg: string) => void; warn?: (msg: string) => void },
+): CorrectionObserverGateResult {
+  const flag = loadFeatureFlagFromWorkspace(workspaceDir, 'correction_observer', logger);
+  if (flag.enabled) {
+    return { shouldStart: true, flagSource: flag.source, disabledInfo: null };
+  }
+  const disabledInfo = JSON.stringify({
+    reason: 'correction_observer_disabled',
+    nextAction: 'set correction_observer.enabled=true in .pd/feature-flags.yaml to enable',
+    featureFlag: 'correction_observer',
+    boundedContext: 'correction_observer_service',
+    flagSource: flag.source,
+  });
+  return { shouldStart: false, flagSource: flag.source, disabledInfo };
+}
+
 const plugin = {
   name: "Principles Disciple",
   description: "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
@@ -246,6 +271,22 @@ const plugin = {
               api.logger.info(`[PD] EvolutionWorker NOT started for workspace: ${workspaceDir}. ${gate.disabledInfo}`);
               SystemLogger.log(workspaceDir, 'EVOLUTION_WORKER_DISABLED', gate.disabledInfo ?? '');
             }
+
+            // ── Start CorrectionObserver for THIS workspace ──
+            // MVP-Core per ADR-0014 amendment, independently owned (PRI-293).
+            const corrGate = shouldStartCorrectionObserver(workspaceDir, api.logger);
+            if (corrGate.shouldStart) {
+              CorrectionObserverService.start({
+                config: api.config,
+                workspaceDir,
+                stateDir: path.join(workspaceDir, '.state'),
+                logger: api.logger,
+              });
+              api.logger.info(`[PD] CorrectionObserver started for workspace: ${workspaceDir} (flag source: ${corrGate.flagSource})`);
+            } else {
+              api.logger.info(`[PD] CorrectionObserver NOT started for workspace: ${workspaceDir}. ${corrGate.disabledInfo}`);
+              SystemLogger.log(workspaceDir, 'CORRECTION_OBSERVER_DISABLED', corrGate.disabledInfo ?? '');
+            }
           }
 
           const result = await handleBeforePromptBuild(event, { ...ctx, api: api as Parameters<typeof handleBeforePromptBuild>[1]['api'], workspaceDir });
@@ -527,6 +568,8 @@ const plugin = {
       EvolutionWorkerService.api = api;
       const guardedEvolutionWorker = guardService('service:evolution-worker', EvolutionWorkerService, api.logger);
       if (guardedEvolutionWorker) api.registerService(guardedEvolutionWorker);
+      const guardedCorrectionObserver = guardService('service:correction-observer', CorrectionObserverService, api.logger);
+      if (guardedCorrectionObserver) api.registerService(guardedCorrectionObserver);
       const guardedTrajectory = guardService('service:trajectory', TrajectoryService, api.logger);
       if (guardedTrajectory) api.registerService(guardedTrajectory);
       const guardedPdTask = guardService('service:pd-task', PDTaskService, api.logger);
@@ -560,24 +603,12 @@ const plugin = {
      
     registerCommandWithAlias('pd-init', 'pdi', getCommandDescription('pd-init', language), (ctx: any) => handleInitStrategy(ctx));
      
-    registerCommandWithAlias('pd-okr', 'pdk', getCommandDescription('pd-okr', language), (ctx: any) => handleManageOkr(ctx));
-     
     registerCommandWithAlias('pd-bootstrap', 'pdb', getCommandDescription('pd-bootstrap', language), (ctx: any) => handleBootstrapTools(ctx));
-     
+
     registerCommandWithAlias('pd-research', 'pdr', getCommandDescription('pd-research', language), (ctx: any) => handleResearchTools(ctx));
-     
+
     registerCommandWithAlias('pd-thinking', 'pdt', getCommandDescription('pd-thinking', language), (ctx: any) => handleThinkingOs(ctx), { acceptsArgs: true });
-     
-    registerCommandWithAlias('pd-daily', 'pdd', getCommandDescription('pd-daily', language), () => ({
-      text: language === 'zh'
-        ? "请执行 pd-daily 技能来配置并发送进化日报。系统将引导你完成配置流程，包括发送时间、渠道和报告风格偏好。"
-        : "Please execute the pd-daily skill to configure and send your daily evolution report. The system will guide you through the configuration process."
-    }));
-    registerCommandWithAlias('pd-grooming', 'pdg', getCommandDescription('pd-grooming', language), () => ({
-      text: language === 'zh'
-        ? "请执行 pd-grooming 技能来执行大扫除。例如输入: '执行 pd-grooming 技能'"
-        : "Please execute the pd-grooming skill to clean up. For example: 'Execute pd-grooming skill'"
-    }));
+
     registerCommandWithAlias('pd-help', 'pdh', getCommandDescription('pd-help', language), () => {
         if (language === 'zh') {
           return { text: `
@@ -593,10 +624,7 @@ const plugin = {
 ## 状态查询
 | 短命令 | 长命令 | 用途 |
 |--------|--------|------|
-| \`/pdk\` | \`/pd-okr\` | OKR 目标管理 |
 | \`/pdt\` | \`/pd-thinking\` | 思维模型管理 |
-| \`/pdd\` | \`/pd-daily\` | 进化日报 |
-| \`/pdg\` | \`/pd-grooming\` | 工作区清理 |
 
 ## 其他命令
 | 命令 | 用途 |
@@ -624,10 +652,7 @@ const plugin = {
 ## Status
 | Short | Full | Purpose |
 |-------|------|---------|
-| \`/pdk\` | \`/pd-okr\` | OKR goal management |
 | \`/pdt\` | \`/pd-thinking\` | Mental model management |
-| \`/pdd\` | \`/pd-daily\` | Evolution report |
-| \`/pdg\` | \`/pd-grooming\` | Workspace cleanup |
 
 ## Other Commands
 | Command | Purpose |

package/src/service/correction-observer-service.ts

@@ -0,0 +1,200 @@
+import type { OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { TrajectoryRegistry } from '../core/trajectory.js';
+import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
+import {
+    WorkflowFunnelLoader,
+    PiAiRuntimeAdapter,
+    CorrectionObserver,
+    AgentScheduler,
+} from '@principles/core/runtime-v2';
+import { KeywordOptimizationService } from './keyword-optimization-service.js';
+import { SystemLogger } from '../core/system-logger.js';
+
+export interface CorrectionObserverServiceShape {
+    id: string;
+    start: (ctx: OpenClawPluginServiceContext) => void;
+    stop?: (ctx: OpenClawPluginServiceContext) => void;
+}
+
+let correctionObserverTimeoutId: ReturnType<typeof setTimeout> | null = null;
+let correctionObserverStopped = false;
+const startedWorkspaces = new Set<string>();
+
+const CORRECTION_OBSERVER_INTERVAL_MS = 15 * 60 * 1000;
+const CORRECTION_OBSERVER_INITIAL_DELAY_MS = 10_000;
+const CORRECTION_OBSERVER_MAX_RECENT_SESSIONS = 20;
+const CORRECTION_OBSERVER_MAX_PAYLOAD_SESSIONS = 5;
+
+export function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): CorrectionObserver | null {
+    try {
+        const loader = new WorkflowFunnelLoader(wctx.stateDir);
+        const funnel = loader.getFunnel('pd-correction-observer');
+        const policy = funnel?.policy;
+        if (!policy || policy.runtimeKind !== 'pi-ai') {
+            logger?.debug?.('[PD:CorrectionObserver] workflows.yaml pd-correction-observer policy not found. Falling back to environment variables.');
+            const provider = process.env.PD_CORRECTION_PROVIDER || 'anthropic';
+            const model = process.env.PD_CORRECTION_MODEL || 'anthropic/claude-3-5-sonnet';
+            const apiKeyEnv = process.env.PD_CORRECTION_API_KEY_ENV || 'ANTHROPIC_API_KEY';
+            const baseUrl = process.env.PD_CORRECTION_BASE_URL;
+
+            if (!process.env[apiKeyEnv]) {
+                logger?.debug?.(`[PD:CorrectionObserver] API key env ${apiKeyEnv} is not set. Periodic optimization disabled.`);
+                return null;
+            }
+
+            const adapter = new PiAiRuntimeAdapter({
+                provider,
+                model,
+                apiKeyEnv,
+                baseUrl,
+                workspace: wctx.workspaceDir,
+            });
+            return new CorrectionObserver({ runtimeAdapter: adapter });
+        }
+
+        const adapter = new PiAiRuntimeAdapter({
+            provider: String(policy.provider),
+            model: String(policy.model),
+            apiKeyEnv: String(policy.apiKeyEnv),
+            maxRetries: policy.maxRetries,
+            timeoutMs: policy.timeoutMs ?? 30_000,
+            baseUrl: policy.baseUrl,
+            workspace: wctx.workspaceDir,
+        });
+        return new CorrectionObserver({ runtimeAdapter: adapter }, { timeoutMs: policy.timeoutMs });
+    } catch (err) {
+        logger?.warn?.(`[PD:CorrectionObserver] Failed to resolve CorrectionObserver: ${String(err)}`);
+        return null;
+    }
+}
+
+export async function runCorrectionObserverCycle(wctx: WorkspaceContext, logger: PluginLogger): Promise<void> {
+    try {
+        const observer = resolveCorrectionObserver(wctx, logger);
+        if (!observer) {
+            logger?.info?.('[PD:CorrectionObserver] Observer not resolved (no API key or config). Skipping cycle.');
+            return;
+        }
+
+        logger?.info?.('[PD:CorrectionObserver] Observer resolved. Initiating periodic optimization...');
+
+        const db = TrajectoryRegistry.get(wctx.workspaceDir);
+        const recentSessions = db.listRecentSessions({ limit: CORRECTION_OBSERVER_MAX_RECENT_SESSIONS });
+        const recentSessionIds = recentSessions.map(s => s.sessionId);
+
+        if (recentSessionIds.length === 0) {
+            logger?.info?.('[PD:CorrectionObserver] No recent sessions found. Skipping correction optimization.');
+            return;
+        }
+
+        const recentMessages: string[] = [];
+        for (const sId of recentSessionIds.slice(0, CORRECTION_OBSERVER_MAX_PAYLOAD_SESSIONS)) {
+            try {
+                const turns = db.listUserTurnsForSession(sId);
+                for (const t of turns) {
+                    if (t.rawExcerpt) {
+                        recentMessages.push(t.rawExcerpt);
+                    }
+                }
+            } catch (turnErr) {
+                logger?.warn?.(`[PD:CorrectionObserver] Failed to load user turns for session ${sId}: ${String(turnErr)}`);
+            }
+        }
+
+        const learner = CorrectionCueLearner.get(wctx.stateDir);
+        const keywords = learner.getStore().keywords;
+        const keywordStoreSummary = {
+            totalKeywords: keywords.length,
+            terms: keywords.map(k => ({
+                term: k.term,
+                weight: k.weight,
+                hitCount: k.hitCount ?? 0,
+                truePositiveCount: k.truePositiveCount ?? 0,
+                falsePositiveCount: k.falsePositiveCount ?? 0,
+            })),
+        };
+
+        const optimizationService = KeywordOptimizationService.get(wctx.stateDir, wctx.workspaceDir, logger);
+        const trajectoryHistory = await optimizationService.buildTrajectoryHistory(recentSessionIds);
+
+        const payload = {
+            parentSessionId: 'correction-observer-service',
+            workspaceDir: wctx.workspaceDir,
+            keywordStoreSummary,
+            recentMessages,
+            trajectoryHistory,
+        };
+
+        const scheduler = new AgentScheduler();
+        scheduler.register({
+            agentId: 'correction-observer',
+            mode: 'realtime',
+            runner: observer,
+        });
+
+        logger?.info?.(`[PD:CorrectionObserver] Dispatching with ${trajectoryHistory.length} trajectory events, ${recentMessages.length} recent messages.`);
+        const result = await scheduler.dispatch('correction-observer', payload);
+        logger?.info?.(`[PD:CorrectionObserver] Completed: updated=${result.updated}, summary="${result.summary}"`);
+
+        if (result.updated) {
+            optimizationService.applyResult(result);
+        }
+    } catch (err) {
+        const errMsg = `Correction observer cycle failed: ${String(err)}`;
+        logger?.warn?.(`[PD:CorrectionObserver] ${errMsg}`);
+        SystemLogger.log(wctx.workspaceDir, 'CORRECTION_OBSERVER_CYCLE_FAILED', errMsg);
+    }
+}
+
+export const CorrectionObserverService: CorrectionObserverServiceShape = {
+    id: 'principles-correction-observer',
+
+    start(ctx: OpenClawPluginServiceContext): void {
+        const workspaceDir = ctx?.workspaceDir;
+        const logger = ctx?.logger || console;
+
+        if (!workspaceDir) {
+            if (logger) logger.warn('[PD:CorrectionObserver] workspaceDir not found in service config. Correction observer disabled.');
+            return;
+        }
+
+        if (startedWorkspaces.has(workspaceDir)) {
+            if (logger) logger.info(`[PD:CorrectionObserver] Already started for workspace: ${workspaceDir}. Skipping duplicate start.`);
+            return;
+        }
+        startedWorkspaces.add(workspaceDir);
+
+        correctionObserverStopped = false;
+
+        const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+        if (logger) logger.info(`[PD:CorrectionObserver] Starting with workspaceDir=${wctx.workspaceDir}, stateDir=${wctx.stateDir}`);
+
+        const interval = CORRECTION_OBSERVER_INTERVAL_MS;
+
+        async function runCycle(): Promise<void> {
+            if (correctionObserverStopped) return;
+            await runCorrectionObserverCycle(wctx, logger);
+            if (correctionObserverStopped) return;
+            correctionObserverTimeoutId = setTimeout(runCycle, interval);
+            correctionObserverTimeoutId.unref();
+        }
+
+        correctionObserverTimeoutId = setTimeout(() => {
+            void runCycle().catch((err) => {
+                if (logger) logger.error(`[PD:CorrectionObserver] Startup cycle failed: ${String(err)}`);
+                if (correctionObserverStopped) return;
+                correctionObserverTimeoutId = setTimeout(runCycle, interval);
+                correctionObserverTimeoutId.unref();
+            });
+        }, CORRECTION_OBSERVER_INITIAL_DELAY_MS);
+        correctionObserverTimeoutId.unref();
+    },
+
+    stop(_ctx: OpenClawPluginServiceContext): void {
+        correctionObserverStopped = true;
+        startedWorkspaces.clear();
+        if (correctionObserverTimeoutId) clearTimeout(correctionObserverTimeoutId);
+        correctionObserverTimeoutId = null;
+    },
+};

package/src/service/evolution-worker.ts

@@ -22,14 +22,7 @@ export { loadEvolutionQueue, saveEvolutionQueue, withQueueLock, acquireQueueLock
 export { EVOLUTION_QUEUE_LOCK_SUFFIX, LOCK_MAX_RETRIES, LOCK_RETRY_DELAY_MS, LOCK_STALE_MS } from './queue-io.js';
 import { saveEvolutionQueue, requireQueueLock } from './queue-io.js';
 import { WorkflowStore } from './subagent-workflow/workflow-store.js';
-import {
-    WorkflowFunnelLoader,
-    PiAiRuntimeAdapter,
-    CorrectionObserver,
-    AgentScheduler,
-} from '@principles/core/runtime-v2';
-import { KeywordOptimizationService } from './keyword-optimization-service.js';
-import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
+
 
 import { PrincipleCompiler } from '../core/principle-compiler/index.js';
 import { loadLedger, updatePrinciple } from '../core/principle-tree-ledger.js';
@@ -632,49 +625,6 @@ async function processEvolutionQueueWithResult(
     return { queue: queueResult, errors };
 }
 
-function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): CorrectionObserver | null {
-  try {
-    const loader = new WorkflowFunnelLoader(wctx.stateDir);
-    const funnel = loader.getFunnel('pd-correction-observer');
-    const policy = funnel?.policy;
-    if (!policy || policy.runtimeKind !== 'pi-ai') {
-      logger?.debug?.('[PD:Correction] workflows.yaml pd-correction-observer policy not found. Falling back to environment variables.');
-      const provider = process.env.PD_CORRECTION_PROVIDER || 'anthropic';
-      const model = process.env.PD_CORRECTION_MODEL || 'anthropic/claude-3-5-sonnet';
-      const apiKeyEnv = process.env.PD_CORRECTION_API_KEY_ENV || 'ANTHROPIC_API_KEY';
-      const baseUrl = process.env.PD_CORRECTION_BASE_URL;
-
-      if (!process.env[apiKeyEnv]) {
-        logger?.debug?.(`[PD:Correction] Correction observer API key env ${apiKeyEnv} is not set. Periodic optimization disabled.`);
-        return null;
-      }
-
-      const adapter = new PiAiRuntimeAdapter({
-        provider,
-        model,
-        apiKeyEnv,
-        baseUrl,
-        workspace: wctx.workspaceDir,
-      });
-      return new CorrectionObserver({ runtimeAdapter: adapter });
-    }
-
-    const adapter = new PiAiRuntimeAdapter({
-      provider: String(policy.provider),
-      model: String(policy.model),
-      apiKeyEnv: String(policy.apiKeyEnv),
-      maxRetries: policy.maxRetries,
-      timeoutMs: policy.timeoutMs ?? 30_000,
-      baseUrl: policy.baseUrl,
-      workspace: wctx.workspaceDir,
-    });
-    return new CorrectionObserver({ runtimeAdapter: adapter }, { timeoutMs: policy.timeoutMs });
-  } catch (err) {
-    logger?.warn?.(`[PD:Correction] Failed to resolve CorrectionObserver: ${String(err)}`);
-    return null;
-  }
-}
-
 export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
     id: 'principles-evolution-worker',
     api: null,
@@ -759,78 +709,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                     await processDetectionQueue(wctx, api, eventLog);
                 }
                 // processPromotion removed (D-06) — promotion via PAIN_CANDIDATES no longer needed
-
-                // ── Correction Observer: periodic keyword optimization (D-40-08 / H-1) ──
-                try {
-                    const observer = resolveCorrectionObserver(wctx, logger);
-                    if (observer) {
-                        logger?.info?.('[PD:EvolutionWorker] Correction Observer resolved. Initiating periodic optimization...');
-                        const db = TrajectoryRegistry.get(wctx.workspaceDir);
-                        const recentSessions = db.listRecentSessions({ limit: 20 });
-                        const recentSessionIds = recentSessions.map(s => s.sessionId);
-
-                        if (recentSessionIds.length > 0) {
-                            const recentMessages: string[] = [];
-                            for (const sId of recentSessionIds.slice(0, 5)) {
-                                try {
-                                    const turns = db.listUserTurnsForSession(sId);
-                                    for (const t of turns) {
-                                        if (t.rawExcerpt) {
-                                            recentMessages.push(t.rawExcerpt);
-                                        }
-                                    }
-                                } catch (turnErr) {
-                                    logger?.warn?.(`[PD:EvolutionWorker] Failed to load user turns for session ${sId}: ${String(turnErr)}`);
-                                }
-                            }
-
-                            const learner = CorrectionCueLearner.get(wctx.stateDir);
-                            const keywords = learner.getStore().keywords;
-                            const keywordStoreSummary = {
-                                totalKeywords: keywords.length,
-                                terms: keywords.map(k => ({
-                                    term: k.term,
-                                    weight: k.weight,
-                                    hitCount: k.hitCount ?? 0,
-                                    truePositiveCount: k.truePositiveCount ?? 0,
-                                    falsePositiveCount: k.falsePositiveCount ?? 0,
-                                })),
-                            };
-
-                            const optimizationService = KeywordOptimizationService.get(wctx.stateDir, wctx.workspaceDir, logger);
-                            const trajectoryHistory = await optimizationService.buildTrajectoryHistory(recentSessionIds);
-
-                            const payload = {
-                                parentSessionId: 'evolution-worker',
-                                workspaceDir: wctx.workspaceDir,
-                                keywordStoreSummary,
-                                recentMessages,
-                                trajectoryHistory,
-                            };
-
-                            const scheduler = new AgentScheduler();
-                            scheduler.register({
-                                agentId: 'correction-observer',
-                                mode: 'realtime',
-                                runner: observer,
-                            });
-
-                            logger?.info?.(`[PD:EvolutionWorker] Dispatching correction-observer with ${trajectoryHistory.length} trajectory events, ${recentMessages.length} recent messages.`);
-                            const result = await scheduler.dispatch('correction-observer', payload);
-                            logger?.info?.(`[PD:EvolutionWorker] Correction-observer completed: updated=${result.updated}, summary="${result.summary}"`);
-                            
-                            if (result.updated) {
-                                optimizationService.applyResult(result);
-                            }
-                        } else {
-                            logger?.info?.('[PD:EvolutionWorker] No recent sessions found. Skipping correction optimization.');
-                        }
-                    }
-                } catch (corrErr) {
-                    const corrErrMsg = `Correction observer execution failed: ${String(corrErr)}`;
-                    cycleResult.errors.push(corrErrMsg);
-                    logger?.warn?.(`[PD:EvolutionWorker] ${corrErrMsg}`);
-                }
+                // Correction Observer extracted to independent service (PRI-293) — no longer runs on EvolutionWorker heartbeat
 
                 try {
                     const subagentRuntime = api?.runtime?.subagent;

package/templates/langs/en/core/BOOTSTRAP.md

@@ -145,12 +145,11 @@ If the user has clear project goals, run `/init-strategy` skill to:
 
 ## ⏰ Cron Jobs Initialization (Recommended)
 
-**Why you need this:** Your HEARTBEAT.md has been simplified to reduce token cost. But the tasks that were removed (grooming, health checks, strategy alignment, weekly governance) are still important — they just moved here. Without these cron jobs, your workspace will accumulate temp files, drift from strategy, and lose track of weekly progress.
+**Why you need this:** Your HEARTBEAT.md has been simplified to reduce token cost. But the tasks that were removed (health checks, strategy alignment, weekly governance) are still important — they just moved here. Without these cron jobs, your workspace will drift from strategy and lose track of weekly progress.
 
 **How to install:** Ask the user for permission, then execute the CLI commands below. Each command creates a background task that runs automatically.
 
 **What you get:**
-- Clean workspace (no temp file buildup)
 - Early warning on tool failures
 - Automatic strategy alignment
 - Weekly governance with evidence-based task validation
@@ -158,24 +157,11 @@ If the user has clear project goals, run `/init-strategy` skill to:
 
 ### Ask the User
 
-> "I can set up background cron jobs for automatic maintenance: cleanup, health checks, strategy alignment, and weekly governance. Should I configure them?"
+> "I can set up background cron jobs for automatic maintenance: health checks, strategy alignment, and weekly governance. Should I configure them?"
 
 If the user agrees, **execute these commands:**
 
-### 1. Grooming (Daily at 2 AM)
-
-**What it does:** Cleans workspace temp files daily to prevent clutter buildup.
-
-```bash
-openclaw cron add --name "pd-grooming-daily" \
-  --cron "0 2 * * *" --tz "UTC" \
-  --session isolated \
-  --light-context \
-  --no-deliver \
-  --message 'Execute pd-grooming skill: Check workspace root, clean temp files and digital clutter. Follow safety rules strictly. Do not delete business code.'
-```
-
-### 2. Health Check (Every 4 hours)
+### 1. Health Check (Every 4 hours)
 
 **What it does:** Verifies core tools (rg, node, python) are available and alerts on failure.
 
@@ -220,7 +206,7 @@ openclaw cron add --name "weekly-governance" \
   --cron "0 0 * * 0" --tz "UTC" \
   --session isolated \
   --timeout 300000 \
-  --message 'Execute weekly governance: 1) Validate CURRENT_FOCUS.md claims (PR merged? docs exist? tests pass?), 2) Update WEEK_STATE.json metrics, 3) Record to WEEK_EVENTS.jsonl, 4) If task queue empty, derive tasks from OKR and notify user'
+  --message 'Execute weekly governance: 1) Validate CURRENT_FOCUS.md claims (PR merged? docs exist? tests pass?), 2) Update WEEK_STATE.json metrics, 3) Record to WEEK_EVENTS.jsonl, 4) If task queue empty, remind user to plan next phase tasks'
 ```
 
 **JSON config reference:**

package/templates/langs/en/skills/bootstrap-tools/SKILL.md

@@ -46,7 +46,7 @@ Your goal is to equip the agent team with the most advanced weapons. By analyzin
             ## Environment Capabilities
             Check @.state/SYSTEM_CAPABILITIES.json for high-performance tools (e.g., ripgrep, ast-grep) available in this environment. Use them!
             ```
-          - Prompt user to run `/manage-okr` or `/admin diagnose` to let Agent perceive new capabilities.
+          - Prompt user to run `/pd-status` or `/admin diagnose` to let Agent perceive new capabilities.
 
 ## Core Principles
 - **Prefer New Over Old**: Dare to recommend new tools to replace old ones (e.g., recommend `pnpm` over `npm`, `vitest` over `jest`), but explain the reasoning.

package/templates/langs/en/skills/init-strategy/SKILL.md

@@ -51,4 +51,4 @@ Based on user's responses, extract 1-3 macro **Objectives (O)**.
 ```
 
 ## Completion
-After writing, prompt user: "✅ Strategic anchor locked. Recommend running `/manage-okr` for quarterly/iteration-level task breakdown."
+After writing, prompt user: "✅ Strategic anchor locked. Recommend running `/pd-status` to check system status, or use `/pd-bootstrap` to scan environment tools."