create-principles-disciple 1.77.0 → 1.78.0

package/plugin/dist/commands/strategy.js

@@ -14,17 +14,3 @@ export function handleInitStrategy(ctx) {
             `Then update \`${userContextPath}\` with key user preferences discovered.`,
     };
 }
-export function handleManageOkr(ctx) {
-    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/plugin/dist/core/runtime-v2-prompt-activation-reader.d.ts

@@ -1,15 +1,6 @@
-export declare const RUNTIME_V2_PRINCIPLE_BUDGET = 2000;
-export interface ActivatedPrinciple {
-    principleId: string;
-    text: string;
-    artifactId: string;
-    activationId: string;
-}
-export interface PromptActivationReaderResult {
-    principles: ActivatedPrinciple[];
-    warnings: string[];
-    source: 'runtime_v2';
-}
+import type { ActivatedPrinciple, PromptActivationReaderResult } from '@principles/core/runtime-v2';
+export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
+export type { ActivatedPrinciple, PromptActivationReaderResult };
 export interface PromptActivationReaderDeps {
     logger?: {
         warn?: (msg: string) => void;
@@ -22,6 +13,6 @@ export declare class PromptActivationReader {
     private readonly deps;
     constructor(workspaceDir: string, deps?: PromptActivationReaderDeps);
     readActivatedPrinciples(): Promise<PromptActivationReaderResult>;
+    private queryArtifactRow;
     private loadFeatureFlags;
-    private resolvePrincipleFromActivation;
 }

package/plugin/dist/core/runtime-v2-prompt-activation-reader.js

@@ -1,8 +1,8 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import * as yaml from 'js-yaml';
-import { SqliteConnection, SqliteActivationStateStore, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS } from '@principles/core/runtime-v2';
-export const RUNTIME_V2_PRINCIPLE_BUDGET = 2000;
+import { SqliteConnection, SqliteActivationStateStore, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS, filterPromptActivations, resolvePrincipleFromArtifact } from '@principles/core/runtime-v2';
+export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
 const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -27,12 +27,27 @@ export class PromptActivationReader {
         try {
             sqliteConn = new SqliteConnection(this.workspaceDir);
             const store = new SqliteActivationStateStore(sqliteConn);
-            const activations = await store.listPromptActivations();
-            for (const activation of activations) {
-                if (activation.channel !== 'prompt' || activation.action !== 'prompt_activate') {
+            const allActivations = await store.listPromptActivations();
+            const promptActivations = filterPromptActivations(allActivations);
+            for (const activation of promptActivations) {
+                let artifactRow;
+                try {
+                    artifactRow = this.queryArtifactRow(sqliteConn, activation.artifactId);
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    const warning = `artifact_query_failed: artifactId=${activation.artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`;
+                    warnings.push(warning);
+                    this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
+                    continue;
+                }
+                if (artifactRow === null) {
+                    const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table`;
+                    warnings.push(warning);
+                    this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
                     continue;
                 }
-                const result = this.resolvePrincipleFromActivation(sqliteConn, activation);
+                const result = resolvePrincipleFromArtifact(artifactRow, activation);
                 if (result.ok) {
                     principles.push(result.principle);
                 }
@@ -58,6 +73,21 @@ export class PromptActivationReader {
         }
         return { principles, warnings, source: 'runtime_v2' };
     }
+    queryArtifactRow(sqliteConn, artifactId) {
+        try {
+            const db = sqliteConn.getDb();
+            const row = db.prepare(`
+        SELECT artifact_id, artifact_kind, content_json, validation_status
+        FROM pi_artifacts
+        WHERE artifact_id = ?
+      `).get(artifactId);
+            return row ?? null;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`artifact_query_failed: artifactId=${artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`);
+        }
+    }
     loadFeatureFlags() {
         const configPath = path.join(this.workspaceDir, '.pd', 'feature-flags.yaml');
         if (!fs.existsSync(configPath)) {
@@ -110,72 +140,4 @@ export class PromptActivationReader {
         }
         return result;
     }
-    resolvePrincipleFromActivation(sqliteConn, activation) {
-        const db = sqliteConn.getDb();
-        let contentJson;
-        try {
-            const row = db.prepare(`
-        SELECT artifact_id, artifact_kind, content_json, validation_status
-        FROM pi_artifacts
-        WHERE artifact_id = ?
-      `).get(activation.artifactId);
-            if (!isRecord(row)) {
-                return { ok: false, warning: `artifact_query_unexpected: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table` };
-            }
-            const artifact_id = Object.hasOwn(row, 'artifact_id') && typeof row.artifact_id === 'string' && row.artifact_id.length > 0 ? row.artifact_id : null;
-            const artifact_kind = Object.hasOwn(row, 'artifact_kind') && typeof row.artifact_kind === 'string' ? row.artifact_kind : null;
-            const raw_content_json = Object.hasOwn(row, 'content_json') && typeof row.content_json === 'string' ? row.content_json : null;
-            const validation_status = Object.hasOwn(row, 'validation_status') && typeof row.validation_status === 'string' ? row.validation_status : null;
-            if (!artifact_id) {
-                return { ok: false, warning: `artifact_not_found: artifactId=${activation.artifactId} activationId=${activation.activationId}; nextAction=verify_artifact_exists_or_remove_stale_activation` };
-            }
-            if (artifact_kind !== 'principle') {
-                return { ok: false, warning: `artifact_not_principle: artifactId=${artifact_id} kind=${artifact_kind ?? 'missing'}; nextAction=skip_non_principle_activations` };
-            }
-            if (validation_status !== 'validated') {
-                return { ok: false, warning: `artifact_not_validated: artifactId=${artifact_id} status=${validation_status ?? 'missing'}; nextAction=skip_unvalidated_artifacts` };
-            }
-            if (raw_content_json === null) {
-                return { ok: false, warning: `artifact_missing_content_json: artifactId=${artifact_id}; nextAction=ensure_artifact_has_content_json` };
-            }
-            contentJson = raw_content_json;
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            return { ok: false, warning: `artifact_query_failed: artifactId=${activation.artifactId} reason=${msg}; nextAction=check_pi_artifacts_table` };
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(contentJson);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            return { ok: false, warning: `artifact_content_json_parse_error: artifactId=${activation.artifactId} reason=${msg}; nextAction=fix_artifact_content_json` };
-        }
-        if (!isRecord(parsed)) {
-            return { ok: false, warning: `artifact_content_malformed: artifactId=${activation.artifactId} reason=parsed_to_non_object; nextAction=fix_artifact_content_json` };
-        }
-        const principleId = Object.hasOwn(parsed, 'principleId') && typeof parsed.principleId === 'string' ? parsed.principleId : undefined;
-        const text = Object.hasOwn(parsed, 'text') && typeof parsed.text === 'string' ? parsed.text : undefined;
-        const draftObj = Object.hasOwn(parsed, 'principleDraft') && isRecord(parsed.principleDraft) ? parsed.principleDraft : null;
-        const draftTitle = draftObj && Object.hasOwn(draftObj, 'title') && typeof draftObj.title === 'string' ? draftObj.title : undefined;
-        const draftStatement = draftObj && Object.hasOwn(draftObj, 'statement') && typeof draftObj.statement === 'string' ? draftObj.statement : undefined;
-        const resolvedPrincipleId = principleId && principleId.length > 0 ? principleId : draftTitle;
-        const resolvedText = text && text.length > 0 ? text : draftStatement;
-        if (!resolvedPrincipleId || resolvedPrincipleId.length === 0) {
-            return { ok: false, warning: `artifact_missing_principle_id: artifactId=${activation.artifactId}; nextAction=ensure_artifact_has_principleId_or_principleDraft_title` };
-        }
-        if (!resolvedText || resolvedText.length === 0) {
-            return { ok: false, warning: `artifact_missing_text: artifactId=${activation.artifactId} principleId=${resolvedPrincipleId}; nextAction=ensure_artifact_has_text_or_principleDraft_statement` };
-        }
-        return {
-            ok: true,
-            principle: {
-                principleId: resolvedPrincipleId,
-                text: resolvedText,
-                artifactId: activation.artifactId,
-                activationId: activation.activationId,
-            },
-        };
-    }
 }

package/plugin/dist/core/surface-guard.d.ts

@@ -0,0 +1,27 @@
+import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, type PluginSurfaceEntry, type MvpCategory } from '@principles/core/runtime-v2';
+import type { OpenClawPluginService } from '../openclaw-sdk.js';
+export interface SurfaceGuardResult {
+    passed: boolean;
+    enabledCoreSurfaces: string[];
+    disabledNonCoreSurfaces: string[];
+    violations: string[];
+    warnings: string[];
+}
+export declare function checkSurfaceGuard(): SurfaceGuardResult;
+export declare function getSurfaceIdForHook(hookEvent: string, label?: string): string;
+export declare function getSurfaceIdForService(serviceName: string): string;
+export declare function isSurfaceEnabled(surfaceId: string, overrides?: Record<string, boolean>): {
+    enabled: boolean;
+    reason?: string;
+};
+export type HookHandler<E, C, R> = (event: E, ctx: C) => R | Promise<R>;
+export declare function guardHook<E, C, R>(surfaceId: string, logger: {
+    info?: (msg: string) => void;
+    debug?: (msg: string) => void;
+} | undefined, handler: HookHandler<E, C, R>): HookHandler<E, C, R>;
+export declare function guardService<T extends OpenClawPluginService>(surfaceId: string, service: T, logger?: {
+    info?: (msg: string) => void;
+    debug?: (msg: string) => void;
+}): T | null;
+export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };
+export type { PluginSurfaceEntry, MvpCategory };

package/plugin/dist/core/surface-guard.js

@@ -0,0 +1,82 @@
+import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, } from '@principles/core/runtime-v2';
+export function checkSurfaceGuard() {
+    const validation = validateSurfaceRegistry(PLUGIN_SURFACE_REGISTRY);
+    const violations = [];
+    const warnings = [...validation.warnings];
+    const coreSurfaces = getSurfacesByCategory(PLUGIN_SURFACE_REGISTRY, 'core');
+    const enabledCore = coreSurfaces.filter(s => s.enabledByDefault);
+    const nonCoreEnabled = PLUGIN_SURFACE_REGISTRY.filter(s => s.category !== 'core' && s.enabledByDefault);
+    if (nonCoreEnabled.length > 0) {
+        for (const surface of nonCoreEnabled) {
+            violations.push(`non-core surface '${surface.id}' (${surface.category}) is enabledByDefault=true — must be false per ADR-0014`);
+        }
+    }
+    if (!validation.valid) {
+        violations.push(...validation.errors);
+    }
+    return {
+        passed: violations.length === 0,
+        enabledCoreSurfaces: enabledCore.map(s => s.id),
+        disabledNonCoreSurfaces: PLUGIN_SURFACE_REGISTRY
+            .filter(s => s.category !== 'core' && !s.enabledByDefault)
+            .map(s => s.id),
+        violations,
+        warnings,
+    };
+}
+export function getSurfaceIdForHook(hookEvent, label) {
+    if (label) {
+        return `hook:${hookEvent}.${label}`;
+    }
+    return `hook:${hookEvent}`;
+}
+export function getSurfaceIdForService(serviceName) {
+    return `service:${serviceName}`;
+}
+export function isSurfaceEnabled(surfaceId, overrides = {}) {
+    const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === surfaceId);
+    if (!entry) {
+        return {
+            enabled: false,
+            reason: `surface '${surfaceId}' not found in registry — classify before enabling (PRI-289)`,
+        };
+    }
+    if (Object.hasOwn(overrides, surfaceId)) {
+        const override = overrides[surfaceId];
+        if (typeof override !== 'boolean') {
+            return { enabled: entry.enabledByDefault, reason: `override for '${surfaceId}' is not boolean, using default` };
+        }
+        if (entry.category === 'gone') {
+            return { enabled: false, reason: `surface '${surfaceId}' is gone and cannot be re-enabled` };
+        }
+        if (entry.category === 'core' && !override) {
+            return { enabled: true, reason: `surface '${surfaceId}' is core and cannot be disabled` };
+        }
+        return { enabled: override };
+    }
+    if (!entry.enabledByDefault && entry.disabledReason) {
+        return { enabled: false, reason: entry.disabledReason };
+    }
+    return { enabled: entry.enabledByDefault };
+}
+export function guardHook(surfaceId, logger, handler) {
+    const check = isSurfaceEnabled(surfaceId);
+    if (check.enabled) {
+        return handler;
+    }
+    const reason = check.reason ?? 'surface not enabled';
+    return (_event, _ctx) => {
+        logger?.info?.(`[PD:surface-guard] SKIP ${surfaceId}: ${reason}`);
+        return undefined;
+    };
+}
+export function guardService(surfaceId, service, logger) {
+    const check = isSurfaceEnabled(surfaceId);
+    if (check.enabled) {
+        return service;
+    }
+    const reason = check.reason ?? 'surface not enabled';
+    logger?.info?.(`[PD:surface-guard] SKIP service ${surfaceId}: ${reason}`);
+    return null;
+}
+export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };

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;