create-principles-disciple 1.75.0 → 1.77.0

package/plugin/dist/core/migration.js

@@ -15,7 +15,6 @@ export function migrateDirectoryStructure(api, 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/plugin/dist/core/path-resolver.js

@@ -240,7 +240,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/plugin/dist/core/paths.d.ts

@@ -47,7 +47,6 @@ export declare const PD_FILES: {
     NOCTURNAL_MEMORY_DIR: string;
     NOCTURNAL_EXPORTS_DIR: string;
     IMPL_CODE_DIR: string;
-    PLAN: string;
     MEMORY_MD: string;
     HEARTBEAT: string;
     SYSTEM_LOG: string;

package/plugin/dist/core/paths.js

@@ -61,7 +61,6 @@ export const PD_FILES = {
     NOCTURNAL_MEMORY_DIR: PD_DIRS.NOCTURNAL_MEMORY,
     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',
     SYSTEM_LOG: posixJoin(PD_DIRS.LOGS, 'SYSTEM.log'),

package/plugin/dist/core/workspace-guidance-migrator.d.ts

@@ -0,0 +1,12 @@
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+interface MigrationError {
+    file: string;
+    error: string;
+}
+export interface MigrationResult {
+    migratedFiles: string[];
+    skippedFiles: string[];
+    errors: MigrationError[];
+}
+export declare function migrateStaleWorkspaceGuidance(api: OpenClawPluginApi, workspaceDir: string): MigrationResult;
+export {};

package/plugin/dist/core/workspace-guidance-migrator.js

@@ -0,0 +1,141 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { migrateWorkspaceGuidance, containsStalePlanMdGuidance } from '@principles/core/runtime-v2';
+const WORKSPACE_GUIDANCE_FILES = [
+    'AGENTS.md',
+    'MEMORY.md',
+];
+const PRINCIPLES_SUBDIR_FILES = [
+    'THINKING_OS.md',
+];
+const SKILLS_DIR = path.join('.principles', 'skills');
+const PRINCIPLES_DIR = '.principles';
+const BACKUP_SUFFIX = '.pre-pri286.bak';
+function readFileContent(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        if (typeof raw !== 'string') {
+            return null;
+        }
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function writeBackup(filePath, content) {
+    const backupPath = filePath + BACKUP_SUFFIX;
+    try {
+        fs.writeFileSync(backupPath, content, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function discoverSkillFiles(workspaceDir) {
+    const skillsDir = path.join(workspaceDir, SKILLS_DIR);
+    if (!fs.existsSync(skillsDir)) {
+        return { files: [] };
+    }
+    try {
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        const skillFiles = [];
+        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) {
+        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, result) {
+    const candidates = [];
+    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, workspaceDir) {
+    const result = {
+        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) {
+            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/plugin/dist/hooks/gate-block-helper.js

@@ -115,34 +115,31 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
             logger.info?.(`[PD_GATE] Gate block recorded without Runtime V2 diagnosis: ${gate.detail}`);
         }
     }
-    // 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, }) {
+    // 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.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`;
 }
 /**
  * Schedule retry for trajectory gate block persistence.

package/plugin/dist/hooks/gate.js

@@ -8,15 +8,12 @@
  * 1. Early Return: Skip if not write/bash/agent tool or no workspace
  * 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';
 import { validateCorrectionProposal, validateProposedPathBounds } from '@principles/core/runtime-v2';
 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';
@@ -31,35 +28,6 @@ export function handleBeforeToolCall(event, ctx) {
         return;
     }
     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);
-            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;
     // Heuristic for bash mutation detection
@@ -74,6 +42,11 @@ export function handleBeforeToolCall(event, ctx) {
             filePath = command;
         }
     }
+    // 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);
@@ -88,8 +61,12 @@ export function handleBeforeToolCall(event, ctx) {
             },
             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',
+                hasPlanFile: false,
             },
             session: {
                 sessionId: ctx.sessionId,
@@ -353,29 +330,6 @@ function _extractParamsSummary(params) {
         summary.new_string = params.new_string;
     return summary;
 }
-function _getPlanStatus(workspaceDir) {
-    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) {
-    try {
-        return fs.existsSync(path.join(workspaceDir, 'PLAN.md'));
-    }
-    catch {
-        return false;
-    }
-}
 function _getCurrentGfi(sessionId) {
     if (!sessionId)
         return 0;

package/plugin/dist/hooks/prompt.d.ts

@@ -40,6 +40,12 @@ export declare function loadContextInjectionConfig(workspaceDir: string): Contex
  * @internal Helper for model configuration resolution
  */
 export declare function getDiagnosticianModel(api: PromptHookApi | null, logger?: PluginLogger): string;
+/**
+ * Extract recent user messages for keyword optimization context.
+ */
+/**
+ * Build prompt for keyword optimization subagent.
+ */
 export declare function handleBeforePromptBuild(event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext & {
     api?: PromptHookApi;
 }): Promise<PluginHookBeforePromptBuildResult | void>;

package/plugin/dist/hooks/prompt.js

@@ -4,11 +4,10 @@ import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbat
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
 import { classifyTask } 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 { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, getKeywordStoreSummary, } from '../core/empathy-keyword-matcher.js';
@@ -51,7 +50,6 @@ function cachedReadFile(filePath) {
 // Module-level empathy state — shared across calls to avoid per-turn I/O
 let _empathyTurnCounter = 0;
 let _empathyKeywordCache = null;
-let _confirmFirstHydrationCounter = 0;
 /**
  * OpenClaw API Prompt Hook
  * Constructs the system prompt injected into LLM context for Principles Disciple
@@ -186,19 +184,6 @@ export function getDiagnosticianModel(api, logger) {
 /**
  * Build prompt for keyword optimization subagent.
  */
-function ensureConfirmFirstStore(workspaceDir) {
-    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, ctx) {
     const { workspaceDir } = ctx;
     const logger = ctx.api?.logger;
@@ -213,17 +198,6 @@ export async function handleBeforePromptBuild(event, ctx) {
     if (sessionId) {
         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 }))
@@ -231,25 +205,6 @@ export async function handleBeforePromptBuild(event, ctx) {
             .find((entry) => entry.message?.role === 'user');
         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 = null;
             try {
@@ -839,19 +794,9 @@ ${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
     // Content order (most important last): behavioral_constraints -> project_context -> working_memory -> reflection_log -> thinking_os -> principles

package/plugin/dist/index.js

@@ -32,15 +32,14 @@ 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';
 import { computeRuntimeShadowTaskFingerprint, PD_LOCAL_PROFILES } from './utils/shadow-fingerprint.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();
 const HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION = 'verify gateway plugin activation and hook workspace binding; ' +
     'migrate live hook workspace resolution to PD-owned canonical configuration before relying on config-based recovery';
@@ -81,18 +80,15 @@ 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/plugin/dist/types/event-types.d.ts

@@ -1,2 +1,2 @@
-export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuntimeV2ConfirmFirstGateEventData, ToolCallStats, ErrorStats, PainStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
+export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, ToolCallStats, ErrorStats, PainStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
 export { createEmptyDailyStats, } from '@principles/core/runtime-v2';

package/plugin/dist/utils/io.d.ts

@@ -4,7 +4,6 @@ export declare function normalizeRiskPath(p: string): string;
 export declare function isRisky(relPath: string, riskPaths: string[]): boolean;
 export declare function parseKvLines(text: string): Record<string, string>;
 export declare function serializeKvLines(data: Record<string, any>): string;
-export declare function planStatus(projectDir: string): string;
 /**
  * Normalize command arguments from PluginCommandContext.args.
  * Handles string | string[] | undefined union by joining arrays with spaces.

package/plugin/dist/utils/io.js

@@ -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.
  *
@@ -141,28 +140,6 @@ export function serializeKvLines(data) {
     }
     return lines.join('\n');
 }
-export function planStatus(projectDir) {
-    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/plugin/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/plugin/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)

package/plugin/templates/langs/en/principles/THINKING_OS.md

@@ -19,7 +19,7 @@ LLMs are highly sensitive to XML tags; this structure is designed to boost instr
 
   <directive id="T-02" name="PHYSICAL_MEMORY_PERSISTENCE">
     <trigger>When reasoning across multiple files, facing complex debugging, or when the conversation context grows long (>5 turns).</trigger>
-    <must>TRUST FILES, NOT YOUR CONTEXT WINDOW. You MUST actively write your intermediate conclusions, breakpoints, and next steps to `memory/.scratchpad.md` or `PLAN.md`.</must>
+    <must>TRUST FILES, NOT YOUR CONTEXT WINDOW. You MUST actively write your intermediate conclusions, breakpoints, and next steps to `memory/.scratchpad.md`.</must>
     <forbidden>Relying on your internal "brain memory" to hold complex state, which will inevitably be wiped by context compression.</forbidden>
   </directive>
 
@@ -39,8 +39,9 @@ LLMs are highly sensitive to XML tags; this structure is designed to boost instr
   <!-- 执行与物理限制 (Execution & Physical Constraints) -->
   <directive id="T-05" name="PHYSICAL_DEFENSE_AND_ORCHESTRATION">
     <trigger>When asked to perform a major refactoring, multi-file change (>2 files), or an architectural shift.</trigger>
-    <must>Limit your blast radius. You MUST draft a `PLAN.md` (status: READY). After any code change, you MUST run canary tests (e.g., `npm test`, linters) to verify integrity.</must>
-    <forbidden>Executing large-scale unstructured changes directly without a plan, or skipping post-modification validation.</forbidden>
+    <should>For complex changes, describe your plan and get owner confirmation before executing.</should>
+    <must>Limit your blast radius. After any code change, you MUST run canary tests (e.g., `npm test`, linters) to verify integrity.</must>
+    <forbidden>Executing large-scale unstructured changes directly, or skipping post-modification validation.</forbidden>
   </directive>
 
   <directive id="T-06" name="OCCAMS_RAZOR_MVC">

package/plugin/templates/langs/en/skills/admin/SKILL.md

@@ -15,7 +15,7 @@ You are now the "Evolutionary System Administrator". Your responsibility is to m
 ### 1. `diagnose` (System Diagnosis)
 **Action**: Check the integrity of the "bare-bones" architecture.
 - **Core Components**: Check if `.claude/hooks/hook_runner.py` exists and is executable.
-- **Documentation Integrity**: Check if `.principles/PROFILE.json`, `PLAN.md` etc. exist.
+- **Documentation Integrity**: Check if `.principles/PROFILE.json` etc. exist.
 - **Tool Awareness**: Check `.state/SYSTEM_CAPABILITIES.json`. If missing, prompt user: "⚠️ Toolchain upgrade not performed. Recommend running `/bootstrap-tools` to significantly enhance system capabilities."
 - **Memory Mount**: Check if `CLAUDE.md` contains `System Integration` section.
 - **Output**: Generate a health report listing missing or abnormal items.
@@ -23,7 +23,7 @@ You are now the "Evolutionary System Administrator". Your responsibility is to m
 ### 2. `repair` (System Repair)
 **Action**: 
 - **Config Recovery**: If `PROFILE.json` is missing or corrupted, attempt recovery from `.claude/templates/PROFILE.json`.
-- **Structure Completion**: Ensure `PLAN.md` contains `## Target Files` heading.
+- **Structure Completion**: Ensure workspace structure is complete.
 - **Forced Cleanup**: Delete `.pain_flag`, `.verdict.json`, `.user_verdict.json`, `.pending_reflection` and other temporary markers.
 
 ### 3. `reset` (Force Reset)