principles-disciple 1.73.0 → 1.75.0

package/INSTALL.md

@@ -236,9 +236,7 @@ After installation, enable the PLAN whitelist feature:
 }
 ```
 
-2. Ensure `docs/PLAN.md` has `STATUS: READY`
-
-3. Restart your agent session
+2. Restart your agent session
 
 Now even Stage 1 agents can edit files when a READY plan exists!
 

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.73.0",
+  "version": "1.75.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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

package/src/core/event-log.ts

@@ -28,7 +28,6 @@ import type {
   RuleHostAutoCorrectProposedEventData,
   RuleHostAutoCorrectAppliedEventData,
   RuntimeV2PromptActivationsInjectedEventData,
-  RuntimeV2ConfirmFirstGateEventData,
 } from '../types/event-types.js';
 import { createEmptyDailyStats } from '../types/event-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
@@ -210,14 +209,6 @@ export class EventLog {
     this.record('runtime_v2_prompt_activations_injected', 'injected', data.sessionId, data);
   }
 
-  recordConfirmFirstGateBlocked(data: RuntimeV2ConfirmFirstGateEventData): void {
-    this.record('runtime_v2_confirm_first_gate_blocked', 'blocked', data.sessionId, data);
-  }
-
-  recordConfirmFirstGateApproved(data: RuntimeV2ConfirmFirstGateEventData): void {
-    this.record('runtime_v2_confirm_first_gate_approved', 'approved', data.sessionId, data);
-  }
-
   private record(
     type: EventType, 
     category: EventCategory, 

package/src/core/migration.ts

@@ -19,7 +19,6 @@ export function migrateDirectoryStructure(api: OpenClawPluginApi, workspaceDir:
             { legacy: path.join(legacyDocsDir, 'PRINCIPLES.md'), newKey: 'PRINCIPLES' },
             { legacy: path.join(legacyDocsDir, 'THINKING_OS.md'), newKey: 'THINKING_OS' },
             { 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, '.pain_flag'), newKey: 'PAIN_FLAG' },
             { legacy: path.join(legacyDocsDir, 'SYSTEM_CAPABILITIES.json'), newKey: 'SYSTEM_CAPABILITIES' },

package/src/core/path-resolver.ts

@@ -306,7 +306,6 @@ export class PathResolver {
             'THINKING_OS': workspacePath.join(workspace, '.principles', 'THINKING_OS.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'),

package/src/core/paths.ts

@@ -68,7 +68,6 @@ export const PD_FILES = {
     NOCTURNAL_EXPORTS_DIR: PD_DIRS.NOCTURNAL_EXPORTS,
     IMPL_CODE_DIR: PD_DIRS.IMPL_CODE_DIR,
 
-    PLAN: 'PLAN.md',
     MEMORY_MD: 'MEMORY.md',
     HEARTBEAT: 'HEARTBEAT.md',
 

package/src/core/workspace-guidance-migrator.ts

@@ -0,0 +1,179 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+import { migrateWorkspaceGuidance, containsStalePlanMdGuidance } from '@principles/core/runtime-v2';
+
+const WORKSPACE_GUIDANCE_FILES = [
+    'AGENTS.md',
+    'MEMORY.md',
+] as const;
+
+const PRINCIPLES_SUBDIR_FILES = [
+    'THINKING_OS.md',
+] as const;
+
+const SKILLS_DIR = path.join('.principles', 'skills');
+const PRINCIPLES_DIR = '.principles';
+const BACKUP_SUFFIX = '.pre-pri286.bak';
+
+interface MigrationError {
+    file: string;
+    error: string;
+}
+
+export interface MigrationResult {
+    migratedFiles: string[];
+    skippedFiles: string[];
+    errors: MigrationError[];
+}
+
+function readFileContent(filePath: string): string | null {
+    try {
+        const raw: unknown = fs.readFileSync(filePath, 'utf-8');
+        if (typeof raw !== 'string') {
+            return null;
+        }
+        return raw;
+    } catch {
+        return null;
+    }
+}
+
+function writeBackup(filePath: string, content: string): boolean {
+    const backupPath = filePath + BACKUP_SUFFIX;
+    try {
+        fs.writeFileSync(backupPath, content, 'utf-8');
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+interface DiscoverResult {
+    files: string[];
+    error?: MigrationError;
+}
+
+function discoverSkillFiles(workspaceDir: string): DiscoverResult {
+    const skillsDir = path.join(workspaceDir, SKILLS_DIR);
+    if (!fs.existsSync(skillsDir)) {
+        return { files: [] };
+    }
+    try {
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        const skillFiles: string[] = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillMd = path.join(skillsDir, entry.name, 'SKILL.md');
+                if (fs.existsSync(skillMd)) {
+                    skillFiles.push(skillMd);
+                }
+            }
+        }
+        return { files: skillFiles };
+    } catch (err: unknown) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        return {
+            files: [],
+            error: {
+                file: SKILLS_DIR,
+                error: `Failed to enumerate skills directory: ${errMsg}`,
+            },
+        };
+    }
+}
+
+function collectCandidateFiles(workspaceDir: string, result: MigrationResult): string[] {
+    const candidates: string[] = [];
+
+    for (const filename of WORKSPACE_GUIDANCE_FILES) {
+        candidates.push(path.join(workspaceDir, filename));
+    }
+
+    for (const filename of PRINCIPLES_SUBDIR_FILES) {
+        candidates.push(path.join(workspaceDir, PRINCIPLES_DIR, filename));
+    }
+
+    const skillDiscovery = discoverSkillFiles(workspaceDir);
+    if (skillDiscovery.error) {
+        result.errors.push(skillDiscovery.error);
+    }
+    candidates.push(...skillDiscovery.files);
+
+    return candidates;
+}
+
+export function migrateStaleWorkspaceGuidance(
+    api: OpenClawPluginApi,
+    workspaceDir: string,
+): MigrationResult {
+    const result: MigrationResult = {
+        migratedFiles: [],
+        skippedFiles: [],
+        errors: [],
+    };
+
+    const candidates = collectCandidateFiles(workspaceDir, result);
+
+    for (const filePath of candidates) {
+        const relativePath = path.relative(workspaceDir, filePath);
+
+        if (!fs.existsSync(filePath)) {
+            continue;
+        }
+
+        const content = readFileContent(filePath);
+        if (content === null) {
+            result.errors.push({
+                file: relativePath,
+                error: 'Failed to read file content',
+            });
+            continue;
+        }
+
+        if (!containsStalePlanMdGuidance(content, relativePath)) {
+            result.skippedFiles.push(relativePath);
+            continue;
+        }
+
+        const migrationResult = migrateWorkspaceGuidance(content, relativePath);
+        if (!migrationResult.changed) {
+            result.skippedFiles.push(relativePath);
+            continue;
+        }
+
+        const migrated = migrationResult.migrated;
+
+        const backupOk = writeBackup(filePath, content);
+        if (!backupOk) {
+            result.errors.push({
+                file: relativePath,
+                error: 'Failed to create backup file before migration',
+            });
+            continue;
+        }
+
+        try {
+            fs.writeFileSync(filePath, migrated, 'utf-8');
+            result.migratedFiles.push(relativePath);
+            api.logger.info(`[PD:GuidanceMigration] Migrated ${relativePath} (backup at ${relativePath}${BACKUP_SUFFIX})`);
+        } catch (writeErr: unknown) {
+            const errMsg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+            result.errors.push({
+                file: relativePath,
+                error: `Failed to write migrated content: ${errMsg}`,
+            });
+            try {
+                fs.writeFileSync(filePath, content, 'utf-8');
+            } catch {
+                api.logger.error(`[PD:GuidanceMigration] CRITICAL: Failed to restore original content for ${relativePath} after write failure`);
+            }
+        }
+    }
+
+    if (result.migratedFiles.length > 0) {
+        api.logger.info(`[PD:GuidanceMigration] Migration complete: ${result.migratedFiles.length} migrated, ${result.skippedFiles.length} skipped, ${result.errors.length} errors`);
+    }
+
+    return result;
+}

package/src/hooks/gate-block-helper.ts

@@ -149,34 +149,39 @@ export function recordGateBlockAndReturn(
     }
   }
 
-  // 6. Return consistent block result with operator guidance
+  // 6. Return consistent block result with contextual operator guidance
+  const blockMessage = buildContextualBlockMessage({ filePath, reason });
+
   return {
     block: true,
-    blockReason: `[Principles Disciple] Security Gate Blocked this action.
+    blockReason: blockMessage,
+  };
+}
+
+/**
+ * Build contextual block message based on block source.
+ * - rule-host: principle-based guidance
+ * - default/gate: generic security gate message
+ */
+function buildContextualBlockMessage({
+  filePath,
+  reason,
+}: {
+  filePath: string;
+  reason: string;
+}): string {
+  // rule-host or generic gate blocks
+  return `[Principles Disciple] Security Gate Blocked this action.
 File: ${filePath}
 Reason: ${reason}
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 📋 How to unblock this operation:
 
-1. Use the plan-script skill to create a PLAN.md:
-   → Invoke: skill:plan-script
-
-2. Fill in the plan with:
-   - Target Files: ${filePath}
-   - Steps: What you want to do (be specific)
-   - Metrics: How to verify success
-   - Active Mental Models: Select 2 relevant models from .principles/THINKING_OS.md
-   - Rollback: How to restore if it fails
-
-3. After completing the plan, set STATUS: READY in PLAN.md
-
-4. Retry the operation
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-This is a mandatory security gate. The operation was blocked because the modification exceeds the allowed threshold for your current evolution tier.
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-  };
+This action was blocked by a Rule Host principle.
+If the blocked path is correct and safe, explain the reasoning to the owner
+and ask for explicit confirmation to proceed.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`;
 }
 
 /**

package/src/hooks/gate.ts

@@ -9,9 +9,7 @@
  * 2. Rule Host: Dynamic principle-based evaluation (sole gate)
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
-import { normalizePath, planStatus } from '../utils/io.js';
+import { normalizePath } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { recordGateBlockAndReturn } from './gate-block-helper.js';
 import { RuleHost } from '../core/rule-host.js';
@@ -19,7 +17,6 @@ import type { RuleHostInput } from '@principles/core/runtime-v2';
 import { validateCorrectionProposal, validateProposedPathBounds } from '@principles/core/runtime-v2';
 import type { PluginHookBeforeToolCallEvent, PluginHookToolContext, PluginHookBeforeToolCallResult, PluginLogger } from '../openclaw-sdk.js';
 import { AGENT_TOOLS, BASH_TOOLS_SET, WRITE_TOOLS } from '../constants/tools.js';
-import { evaluateConfirmFirstGateSync } from '../core/confirm-first-gate.js';
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
 import { getEvolutionEngine } from '../core/evolution-engine.js';
 import { EventLogService } from '../core/event-log.js';
@@ -42,42 +39,6 @@ export function handleBeforeToolCall(
 
   const wctx = WorkspaceContext.fromHookContext(ctx);
 
-  // 1.5. Confirm-First Gate — runs BEFORE filePath resolution to catch apply_patch/no-path cases
-  try {
-    const cfResult = evaluateConfirmFirstGateSync(
-      ctx.sessionId,
-      event.toolName,
-      event.params,
-    );
-
-    if (cfResult.action === 'block') {
-      const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
-      eventLog.recordConfirmFirstGateBlocked({
-        sessionId: ctx.sessionId ?? 'unknown',
-        workspaceDir: ctx.workspaceDir,
-        toolName: event.toolName,
-        reason: cfResult.reason ?? 'confirm_first_required',
-        principleId: cfResult.principleId ?? 'unknown',
-        nextAction: cfResult.nextAction ?? '',
-      });
-
-      // Use safe placeholder when filePath is unavailable (e.g., apply_patch with no path)
-      const safePath = (event.params?.file_path || event.params?.path || event.params?.file || event.params?.target)
-        ?? `<tool:${event.toolName}>`;
-
-      return recordGateBlockAndReturn(wctx, {
-        filePath: typeof safePath === 'string' ? safePath : `<tool:${event.toolName}>`,
-        reason: cfResult.reason ?? 'confirm_first_required',
-        toolName: event.toolName,
-        sessionId: ctx.sessionId,
-        blockSource: 'confirm-first-gate',
-      }, logger);
-    }
-  } catch (cfErr) {
-    // ERR-002: fail loud — log but do not crash the gate
-    logger?.warn?.(`[PD:ConfirmFirst] Gate evaluation failed (non-blocking): ${String(cfErr)}`);
-  }
-
   // 2. Resolve the target file path
   let filePath = event.params?.file_path || event.params?.path || event.params?.file || event.params?.target;
 
@@ -94,6 +55,12 @@ export function handleBeforeToolCall(
     }
   }
 
+  // Write tools without a file path must still go through RuleHost evaluation.
+  // Use a synthetic path so RuleHost can evaluate and potentially block.
+  if (!filePath && isWriteTool) {
+    filePath = `<tool:${event.toolName}>`;
+  }
+
   if (typeof filePath !== 'string') return;
 
   const relPath = normalizePath(filePath, ctx.workspaceDir);
@@ -109,8 +76,12 @@ export function handleBeforeToolCall(
       },
       workspace: {
         isRiskPath: false, // Rule Host determines risk dynamically
-        planStatus: _getPlanStatus(ctx.workspaceDir),
-        hasPlanFile: _hasPlanFile(ctx.workspaceDir),
+        // DEPRECATED (PRI-286): planStatus/hasPlanFile are legacy compatibility fields.
+        // Live PD no longer reads or manages PLAN.md state. These fields must not be
+        // used for new MVP behavior. Future "plan-first" enforcement must come from
+        // owner-approved RuleHost/code_tool_hook activation, not built-in state.
+        planStatus: 'NONE' as const,
+        hasPlanFile: false,
       },
       session: {
         sessionId: ctx.sessionId,
@@ -377,25 +348,6 @@ function _extractParamsSummary(params: Record<string, unknown>): Record<string,
   return summary;
 }
 
-function _getPlanStatus(workspaceDir: string): 'NONE' | 'DRAFT' | 'READY' | 'UNKNOWN' {
-  try {
-    const status = planStatus(workspaceDir);
-    if (status === 'READY') return 'READY';
-    if (status === 'DRAFT') return 'DRAFT';
-    if (status === '') return 'NONE';
-    return 'UNKNOWN';
-  } catch {
-    return 'UNKNOWN';
-  }
-}
-
-function _hasPlanFile(workspaceDir: string): boolean {
-  try {
-    return fs.existsSync(path.join(workspaceDir, 'PLAN.md'));
-  } catch {
-    return false;
-  }
-}
 
 function _getCurrentGfi(sessionId?: string): number {
   if (!sessionId) return 0;

package/src/hooks/prompt.ts

@@ -8,11 +8,10 @@ import { WorkspaceContext } from '../core/workspace-context.js';
 import type { ContextInjectionConfig} from '../types.js';
 import { defaultContextConfig } from '../types.js';
 import { classifyTask, type RoutingInput } from '../core/local-worker-routing.js';
-import { detectApprovalMarker, setConfirmFirstApproval, setConfirmFirstDirective, hydrateFromStore, pruneStoreStaleRows, setConfirmFirstStore, resetConfirmFirst } from '../core/confirm-first-gate.js';
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { PathResolver } from '../core/path-resolver.js';
 import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/principle-injection.js';
-import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler, SqliteConfirmFirstStateStore, SqliteConnection } from '@principles/core/runtime-v2';
+import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler } from '@principles/core/runtime-v2';
 import { truncateInjectionToBudget } from '@principles/core/prompt-builder';
 import { PromptActivationReader, RUNTIME_V2_PRINCIPLE_BUDGET } from '../core/runtime-v2-prompt-activation-reader.js';
 import {
@@ -77,7 +76,6 @@ function cachedReadFile(filePath: string): string {
 // Module-level empathy state — shared across calls to avoid per-turn I/O
 let _empathyTurnCounter = 0;
 let _empathyKeywordCache: { store: ReturnType<typeof loadKeywordStore>; lang: string } | null = null;
-let _confirmFirstHydrationCounter = 0;
 
 /**
  * Model configuration with primary model and optional fallback models
@@ -265,19 +263,6 @@ export function getDiagnosticianModel(api: PromptHookApi | null, logger?: Plugin
  */
 
 
-function ensureConfirmFirstStore(workspaceDir: string): void {
-  if (!_confirmFirstStoreInitialized) {
-    try {
-      const connection = new SqliteConnection({ workspaceDir, readonly: false });
-      setConfirmFirstStore(new SqliteConfirmFirstStateStore(connection));
-      _confirmFirstStoreInitialized = true;
-    } catch (err) {
-      console.warn(`[PD:ConfirmFirst] Failed to initialize store: ${String(err)}`);
-    }
-  }
-}
-let _confirmFirstStoreInitialized = false;
-
 export async function handleBeforePromptBuild(
   event: PluginHookBeforePromptBuildEvent,
   ctx: PluginHookAgentContext & { api?: PromptHookApi }
@@ -297,18 +282,6 @@ export async function handleBeforePromptBuild(
     wctx.trajectory?.recordSession?.({ sessionId });
   }
 
-  if (sessionId) {
-    ensureConfirmFirstStore(workspaceDir);
-    hydrateFromStore(sessionId);
-    _confirmFirstHydrationCounter++;
-    if (_confirmFirstHydrationCounter % 100 === 0) {
-      const pruned = pruneStoreStaleRows();
-      if (pruned > 0) {
-        logger?.info?.(`[PD:ConfirmFirst] Pruned ${pruned} stale rows from confirm_first_state`);
-      }
-    }
-  }
-
   if (sessionId && trigger === 'user' && Array.isArray(event.messages) && event.messages.length > 0) {
     const latestUserIndex = [...event.messages]
       .map((message, index) => ({ message, index }))
@@ -318,25 +291,6 @@ export async function handleBeforePromptBuild(
     if (latestUserIndex) {
       const userText = getTextContent(latestUserIndex.message);
 
-      // ── Confirm-first approval detection ──
-      // If user sends approval language, mark session as approved for confirm-first gate
-      if (sessionId && detectApprovalMarker(userText)) {
-        setConfirmFirstApproval(sessionId);
-        // P2: Emit approval telemetry for observability (ERR-002)
-        try {
-          wctx.eventLog.recordConfirmFirstGateApproved({
-            sessionId,
-            workspaceDir: wctx.workspaceDir,
-            toolName: '(approval)',
-            reason: 'user_approval_detected',
-            principleId: 'confirm-first',
-            nextAction: 'mutating tools now permitted',
-          });
-        } catch (logErr) {
-          logger?.warn?.(`[PD:ConfirmFirst] Failed to emit approval event: ${String(logErr)}`);
-        }
-      }
-
       // Use CorrectionCueLearner for detection — supports learned keywords, not just hardcoded list
       let correctionCue: string | null = null;
       try {
@@ -990,22 +944,8 @@ ${heartbeatChecklist}
     } catch (logErr) {
       logger?.warn?.(`[PD:RuntimeV2] Failed to emit activation observability event: ${String(logErr)}`);
     }
-
-    // ── Set confirm-first directive state for gate enforcement ──
-    if (sessionId) {
-      const cfPrinciple = dedupedV2.find(
-        (p) =>
-          p.principleId === 'princ-mvp-acceptance-confirm-first' ||
-          (p.text.toLowerCase().includes('confirm requirements') &&
-           p.text.toLowerCase().includes('owner approval')),
-      );
-      setConfirmFirstDirective(sessionId, !!cfPrinciple, cfPrinciple?.principleId);
-    }
   } catch (e) {
     logger?.warn?.(`[PD:RuntimeV2] Failed to read Runtime V2 prompt activations: ${String(e)}`);
-    if (sessionId) {
-      resetConfirmFirst(sessionId);
-    }
   }
 
   // Build appendSystemContext with recency effect

package/src/index.ts

@@ -51,6 +51,7 @@ import { PDTaskService } from './core/pd-task-service.js';
 import { CentralSyncService } from './service/central-sync-service.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
+import { migrateStaleWorkspaceGuidance } from './core/workspace-guidance-migrator.js';
 import { SystemLogger } from './core/system-logger.js';
 import { PathResolver } from './core/path-resolver.js';
 import { resolveCommandWorkspaceDir, resolveToolHookWorkspaceDirSafe } from './utils/workspace-resolver.js';
@@ -59,9 +60,7 @@ import type { WorkerProfile } from './core/model-deployment-registry.js';
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
 import { resolveWorkspaceDirFromApi } from './core/path-resolver.js';
 
-// Track initialization to avoid repeated calls
-let workspaceInitialized = false;
-// Track started evolution workers — one per workspace
+// Track started workspaces — one-time init + evolution worker per workspace
 const startedWorkspaces = new Set<string>();
 
 const HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION =
@@ -113,19 +112,16 @@ const plugin = {
           return;
         }
         try {
-          if (!workspaceInitialized) {
+          if (!startedWorkspaces.has(workspaceDir)) {
+            startedWorkspaces.add(workspaceDir);
             migrateDirectoryStructure(api, workspaceDir);
+            migrateStaleWorkspaceGuidance(api, workspaceDir);
             ensureWorkspaceTemplates(api, workspaceDir, language);
             SystemLogger.log(workspaceDir, 'SYSTEM_BOOT', `Principles Disciple online. Language: ${language}`);
-            workspaceInitialized = true;
-          }
 
-          // ── Start EvolutionWorker for THIS workspace ──
-          // Each agent has its own heartbeat task. When before_prompt_build fires,
-          // it fires for the current agent's workspaceDir. Start one EvolutionWorker
-          // per workspace so each agent's pain signals are processed independently.
-          if (!startedWorkspaces.has(workspaceDir)) {
-            startedWorkspaces.add(workspaceDir);
+            // ── Start EvolutionWorker for THIS workspace ──
+            // One EvolutionWorker per workspace so each agent's pain signals
+            // are processed independently.
             EvolutionWorkerService.api = api;
             EvolutionWorkerService.start({
               config: api.config,

package/src/types/event-types.ts

@@ -23,7 +23,6 @@ export type {
   RuleHostAutoCorrectProposedEventData,
   RuleHostAutoCorrectAppliedEventData,
   RuntimeV2PromptActivationsInjectedEventData,
-  RuntimeV2ConfirmFirstGateEventData,
   ToolCallStats,
   ErrorStats,
   PainStats,

package/src/utils/io.ts

@@ -1,6 +1,5 @@
 import * as path from 'path';
 import * as fs from 'fs';
-import { resolvePdPath } from '../core/paths.js';
 
 /**
  * Atomic file write — write to temp then rename to prevent partial writes on crash.
@@ -148,27 +147,6 @@ export function serializeKvLines(data: Record<string, any>): string {
   return lines.join('\n');
 }
 
-export function planStatus(projectDir: string): string {
-  const planPath = resolvePdPath(projectDir, 'PLAN');
-  try {
-    if (!fs.existsSync(planPath)) return '';
-    const content = fs.readFileSync(planPath, 'utf8');
-    const lines = content.split('\n');
-    for (const line of lines) {
-      if (line.startsWith('STATUS:')) {
-        const parts = line.split(':');
-        if (parts.length > 1) {
-           return parts[1].trim().split(/\s+/)[0] || '';
-        }
-      }
-    }
-  /* eslint-disable @typescript-eslint/no-unused-vars -- Reason: Error is intentionally ignored for graceful degradation */
-  } catch (_e) {
-    // Ignore read errors
-  }
-  return '';
-}
-
 /**
  * Normalize command arguments from PluginCommandContext.args.
  * Handles string | string[] | undefined union by joining arrays with spaces.

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

@@ -17,7 +17,6 @@ As Principles Disciple, you must distinguish between two physical spaces:
 Make decisions based on relative paths in the **Project Battlefield**:
 
 - **Strategic Focus**: `./memory/STRATEGY.md`
-- **Physical Plan**: `./PLAN.md`
 - **Pain Signal**: Runtime V2 `PainSignalBridge` (`pd pain record` for manual trigger; `.state/.pain_flag` is legacy compatibility only)
 - **System Capabilities**: `./.state/SYSTEM_CAPABILITIES.json`
 
@@ -166,12 +165,13 @@ On platforms that support reactions (Discord, Slack), use emoji reactions natura
 You default to architect mode.
 
 - **L1 (Direct Execution)**: Single-file tweaks, doc maintenance → do it directly
-- **L2 (Delegation Protocol)**: Major changes → **MUST** update `./PLAN.md` and use `pd_spawn_agent` tool
+- **L2 (Delegation Protocol)**: Major changes → recommended to describe the plan and get owner confirmation before executing
 
-### State Machine Gating
+### Planning Guidance
 
-- **Single source of truth**: `./PLAN.md`
-- **Physical interception**: Plugin activated. If `PLAN.md` is not `READY` and you attempt to modify risk paths, calls will be blocked
+- For complex tasks, consider drafting a plan document and getting owner approval before making large changes
+- This is a behavioral suggestion, not a built-in gate — PD does not enforce plan-before-action by default
+- If an owner-approved RuleHost rule enforces planning behavior, that rule takes effect automatically
 - **Prevent pollution**: Never write execution details back to strategic documents
 
 ---

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

@@ -183,7 +183,7 @@ openclaw cron add --name "pd-grooming-daily" \
 openclaw cron add --name "health-check" \
   --every 4h \
   --session main \
-  --system-event 'Health check: Verify core tools (rg, node, python) are available. Check if PLAN.md state matches actual progress.'
+  --system-event 'Health check: Verify core tools (rg, node, python) are available. Check if workspace state matches actual progress.'
 ```
 
 ### 3. Strategy Alignment (Daily at 9 AM)