create-principles-disciple 1.76.0 → 1.78.0

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/prompt.js

@@ -3,19 +3,20 @@ import * as path from 'path';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds, trackFriction, decayGfi, getGfiDecayElapsed } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
-import { classifyTask } from '../core/local-worker-routing.js';
+// local-worker-routing: removed from prompt injection per PRI-291 (MVP-Quiet)
+// classifyTask is still available for non-prompt consumers
 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 } from '@principles/core/runtime-v2';
+import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler, RUNTIME_V2_PRINCIPLE_BUDGET, trimToBudget, renderPrinciplesToDirectives } 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 { PromptActivationReader } from '../core/runtime-v2-prompt-activation-reader.js';
 import { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, getKeywordStoreSummary, } from '../core/empathy-keyword-matcher.js';
 import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empathy-types.js';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import { buildAttitudeDirective, detectCorrectionCue as coreDetectCorrectionCue, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
+import { detectCorrectionCue as coreDetectCorrectionCue, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
 // ---------------------------------------------------------------------------
 // Static file cache — avoids re-reading rarely-changing files every message
 // ---------------------------------------------------------------------------
@@ -576,9 +577,9 @@ ${heartbeatChecklist}
             }
         }
     }
-    // ──── 6. Dynamic Attitude Matrix (based on GFI) ────
-    const currentGfi = session?.currentGfi || 0;
-    const attitudeDirective = buildAttitudeDirective(currentGfi);
+    // ──── 6. GFI score (for empathy/evidence path only — NOT for attitude/personality prompt)
+    // Attitude/personality prompt injection removed per PRI-291 (MVP diet).
+    // GFI scoring, trackFriction, and empathy pain emission remain active.
     // ──── 7. appendSystemContext: Principles + Thinking OS + reflection_log + project_context ────
     // NOTE: Principles is ALWAYS injected (not configurable)
     // Thinking OS, reflection_log, project_context are configurable
@@ -750,19 +751,12 @@ ${heartbeatChecklist}
         }
         dedupedV2 = v2Result.principles.filter((p) => !legacyActiveIds.has(p.principleId));
         if (dedupedV2.length > 0) {
-            let remaining = RUNTIME_V2_PRINCIPLE_BUDGET;
-            const lines = [];
-            lines.push('Runtime V2 activated principles (owner-approved):');
-            remaining -= 'Runtime V2 activated principles (owner-approved):'.length;
-            for (const p of dedupedV2) {
-                const entry = `- [${escapeXml(p.principleId)}] ${escapeXml(p.text)}`;
-                if (remaining < entry.length + 1) {
-                    logger?.info?.(`[PD:RuntimeV2] Principle budget reached (${RUNTIME_V2_PRINCIPLE_BUDGET}c) — truncating after ${lines.length - 1} principles`);
-                    break;
-                }
-                lines.push(entry);
-                remaining -= entry.length + 1;
-                runtimeV2PrincipleIds.add(p.principleId);
+            const { lines, injectedIds, truncated } = trimToBudget(dedupedV2, RUNTIME_V2_PRINCIPLE_BUDGET, escapeXml);
+            if (truncated) {
+                logger?.info?.(`[PD:RuntimeV2] Principle budget reached (${RUNTIME_V2_PRINCIPLE_BUDGET}c) — truncating after ${injectedIds.size} principles`);
+            }
+            for (const id of injectedIds) {
+                runtimeV2PrincipleIds.add(id);
             }
             runtimeV2PrinciplesContent = lines.join('\n');
         }
@@ -829,122 +823,12 @@ ${empathySilenceConstraint}
     // PLACED IN prependSystemContext (before gateway system prompt) for highest LLM attention.
     // These are owner-reviewed, validated behavior constraints — not background context.
     if (runtimeV2PrincipleIds.size > 0) {
-        const directiveLines = [];
-        directiveLines.push('');
-        directiveLines.push('## 【OWNER-APPROVED BEHAVIOR DIRECTIVES】');
-        directiveLines.push('');
-        directiveLines.push('Owner-approved behavior directives are active operating constraints learned from prior owner corrections.');
-        directiveLines.push('These directives are mandatory for this session unless they conflict with safety, security, or higher-priority system policy.');
-        directiveLines.push('For ambiguous coding or file-changing tasks, follow these directives before using mutating tools.');
-        directiveLines.push('');
-        for (const p of dedupedV2) {
-            if (!runtimeV2PrincipleIds.has(p.principleId))
-                continue;
-            directiveLines.push(`<directive id="${escapeXml(p.principleId)}" source="runtime_v2_activation">`);
-            directiveLines.push(`MANDATORY: ${escapeXml(p.text)}`);
-            directiveLines.push('Apply this as an active behavior constraint. Do not treat this as background context.');
-            directiveLines.push('</directive>');
-            directiveLines.push('');
-        }
-        directiveLines.push('Note: These directives do not override safety, security, or core system policy.');
-        prependSystemContext += directiveLines.join('\n');
-    }
-    // Routing Guidance (section 5 — injected between evolution principles and core principles)
-    // Inject delegation guidance when task is bounded + deployment allowed + not high-entropy.
-    // This is a non-authoritative suggestion — the main agent decides whether to follow.
-    // Shadow evidence comes from real runtime hooks (subagent_spawning/subagent_ended).
-    if (!isMinimalMode && sessionId) {
-        try {
-            // Use the already extracted and cleaned user message
-            const latestUserText = latestUserMessage || '';
-            if (latestUserText && latestUserText.trim().length > 0) {
-                // Infer requestedTools and requestedFiles from message content
-                const toolPatterns = [
-                    { pattern: /\b(edit|replace|write|modify|update|fix|patch|add|remove|delete|insert)\b/gi, tool: 'edit' },
-                    { pattern: /\b(read|cat|view|show|get|find|search|grep|look|inspect|examine|list|head|tail|diff)\b/gi, tool: 'read' },
-                    { pattern: /\b(run|execute|exec|bash|shell|command)\b/gi, tool: 'bash' },
-                ];
-                const filePattern = /\b([a-zA-Z]:\\?[^\s,]+\.[a-z]{2,10}|[./][^\s,]+\.[a-z]{2,10})\b/gi;
-                const toolMatches = toolPatterns.flatMap(({ pattern, tool }) => {
-                    const matches = [];
-                    const r = new RegExp(pattern.source, pattern.flags);
-                    while (r.exec(latestUserText) !== null)
-                        matches.push(tool);
-                    return matches;
-                });
-                const fileMatches = latestUserText.match(filePattern) ?? [];
-                const routingInput = {
-                    taskIntent: toolMatches[0] ?? undefined,
-                    taskDescription: latestUserText.trim(),
-                    requestedFiles: fileMatches.length > 0 ? fileMatches : undefined,
-                };
-                const decision = classifyTask(routingInput, wctx.stateDir);
-                // Inject guidance only when: route_local + deployable checkpoint + not high-entropy
-                const isDeployableState = decision.activeCheckpointState === 'shadow_ready' ||
-                    decision.activeCheckpointState === 'promotable';
-                if (decision.decision === 'route_local' &&
-                    decision.targetProfile !== null &&
-                    isDeployableState) {
-                    const profile = decision.targetProfile;
-                    if (profile === 'local-reader') {
-                        appendParts.push(`<routing_guidance>
-DELEGATION SUGGESTION: This task appears suitable for the local-reader subagent.
-
-**Task Fit**: ${decision.reason}
-
-**Suggested Action**: Consider routing to \`local-reader\` (pd-explorer skill) for focused reading, inspection, and information retrieval.
-
-**Why This Works**:
-- Task keywords indicate read-only or inspect operations
-- Bounded scope — no multi-file coordination needed
-- Shadow observation in progress — real runtime evidence being collected
-
-**Note**: This is a non-authoritative suggestion. The main agent decides whether to route based on full context. Shadow evidence from runtime hooks will inform future promotion decisions.
-</routing_guidance>`);
-                    }
-                    else if (profile === 'local-editor') {
-                        appendParts.push(`<routing_guidance>
-DELEGATION SUGGESTION: This task appears suitable for the local-editor subagent.
-
-**Task Fit**: ${decision.reason}
-
-**Suggested Action**: Consider routing to \`local-editor\` (pd-repair skill) for bounded editing, modification, and repair tasks.
-
-**Why This Works**:
-- Task keywords indicate bounded modification operations
-- Target files appear limited in scope (1-3 files)
-- Shadow observation in progress — real runtime evidence being collected
-
-**Note**: This is a non-authoritative suggestion. The main agent decides whether to route based on full context. Shadow evidence from runtime hooks will inform future promotion decisions.
-</routing_guidance>`);
-                    }
-                }
-                else if (decision.decision === 'stay_main' &&
-                    decision.classification !== 'reader_eligible' &&
-                    decision.classification !== 'editor_eligible') {
-                    // Only show stay_main guidance when the task is genuinely high-entropy/risk/ambiguous
-                    appendParts.push(`<routing_guidance>
-ROUTING GUIDANCE: Task should remain on the main agent.
-
-**Reason**: ${decision.reason}
-
-**Blockers**: ${decision.blockers.length > 0 ? decision.blockers.join('; ') : 'none'}
-
-**Why Stay Main**:
-- Task contains high-entropy signals (open-ended, multi-step, or ambiguous)
-- Or: task involves risk signals requiring main-agent supervision
-- Or: deployment not available for the natural target profile
-
-**Note**: This is a non-authoritative suggestion backed by policy classification. The main agent has full discretion.
-</routing_guidance>`);
-                }
-            }
-        }
-        catch (e) {
-            // Routing guidance is best-effort — never fail the hook
-            logger?.warn?.(`[PD:Prompt] Routing guidance injection failed: ${String(e)}`);
-        }
+        const directiveText = renderPrinciplesToDirectives(dedupedV2, runtimeV2PrincipleIds, escapeXml);
+        prependSystemContext += directiveText;
     }
+    // Routing guidance removed per PRI-291 (MVP diet).
+    // Local worker routing is MVP-Quiet per ADR-0014 §2.5.
+    // The classifyTask helper and local-worker-routing module are preserved for non-prompt consumers.
     // 6. Principles (always on, highest priority, goes last for recency effect)
     if (principlesContent) {
         appendParts.push(`<core_principles>\n${principlesContent}\n</core_principles>`);
@@ -964,15 +848,8 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
 **【EXECUTION RULES】** (Priority: Low → High):
 - \`<behavioral_constraints>\` - Output format restrictions (hide diagnostic JSON)
 - \`<project_context>\` - Current priorities (can be overridden)
-- \`<reflection_log>\` - Past lessons (inform your approach)
-- \`<thinking_os>\` - Thinking models (guide your reasoning)
-- \`<evolution_principles>\` - Newly learned principles (active + probation)
-- \`<routing_guidance>\` - Delegation suggestions (non-authoritative, best-effort)
+- \`<evolution_principles>\` - Learned principles (active + probation)
 - \`<core_principles>\` - Core rules (NON-NEGOTIABLE, highest priority)
-
-**Remember**: You are the Spicy Evolver. You despise entropy. You evolve through pain.
-
-${attitudeDirective}
 `;
     }
     // ──── 8. SIZE GUARD ────

package/plugin/dist/i18n/commands.js

@@ -18,10 +18,6 @@ export const commandDescriptions = {
         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'
@@ -31,16 +27,8 @@ export const commandDescriptions = {
         en: 'Research tool upgrade solutions'
     },
     'pd-thinking': {
-        zh: '管理思维模型 [status|propose|audit]',
-        en: 'Manage Thinking OS [status|propose|audit]'
-    },
-    'pd-daily': {
-        zh: '配置并发送进化日报',
-        en: 'Configure and send daily evolution report'
-    },
-    'pd-grooming': {
-        zh: '工作区清理与大扫除',
-        en: 'Workspace cleanup and grooming'
+        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-help': {
         zh: '显示所有命令和使用指南',

package/plugin/dist/index.d.ts

@@ -1,8 +1,35 @@
 import type { OpenClawPluginApi } from './openclaw-sdk.js';
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+declare function loadFeatureFlagFromWorkspace(workspaceDir: string, flagId: string, logger?: {
+    warn?: (msg: string) => void;
+    info?: (msg: string) => void;
+}): {
+    enabled: boolean;
+    source: string;
+};
+export interface EvolutionWorkerGateResult {
+    shouldStart: boolean;
+    flagSource: string;
+    disabledInfo: string | null;
+}
+export declare function shouldStartEvolutionWorker(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): EvolutionWorkerGateResult;
+export interface CorrectionObserverGateResult {
+    shouldStart: boolean;
+    flagSource: string;
+    disabledInfo: string | null;
+}
+export declare function shouldStartCorrectionObserver(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): CorrectionObserverGateResult;
 declare const plugin: {
     name: string;
     description: string;
     register(api: OpenClawPluginApi): void;
 };
 export { PrincipleTreeLedgerAdapter } from './core/principle-tree-ledger-adapter.js';
+export { loadFeatureFlagFromWorkspace, isRecord };
 export default plugin;