principles-disciple 1.76.0 → 1.78.0

package/openclaw.plugin.json

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

package/package.json

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

package/src/commands/context.ts

@@ -226,7 +226,7 @@ function applyPreset(
             break;
         case 'standard':
             config = {
-                thinkingOs: true,
+                thinkingOs: false,
                 projectFocus: 'off',
                 evolutionContext: { ...defaultContextConfig.evolutionContext }
             };
@@ -272,8 +272,8 @@ function showHelp(isZh: boolean): string {
 
 **预设模式**:
 \`/pd-context minimal\` - 最小模式（仅核心原则）
-\`/pd-context standard\` - 标准模式（原则+思维模型）
-\`/pd-context full\` - 完整模式（全部开启）
+\`/pd-context standard\` - 标准模式（原则，不含思维模型）
+\`/pd-context full\` - 完整模式（原则+思维模型+项目上下文）
 
 **注意**: 核心原则始终注入，不可关闭。
 `.trim();
@@ -291,8 +291,8 @@ function showHelp(isZh: boolean): string {
 
 **Presets**:
 \`/pd-context minimal\` - Minimal mode (core principles only)
-\`/pd-context standard\` - Standard mode (principles + thinking)
-\`/pd-context full\` - Full mode (all enabled)
+\`/pd-context standard\` - Standard mode (principles, no Thinking OS)
+\`/pd-context full\` - Full mode (principles + Thinking OS + project context)
 
 **Note**: Core Principles are always injected and cannot be disabled.
 `.trim();

package/src/core/surface-guard.ts

@@ -0,0 +1,130 @@
+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 function checkSurfaceGuard(): SurfaceGuardResult {
+  const validation = validateSurfaceRegistry(PLUGIN_SURFACE_REGISTRY);
+  const violations: string[] = [];
+  const warnings: string[] = [...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: string, label?: string): string {
+  if (label) {
+    return `hook:${hookEvent}.${label}`;
+  }
+  return `hook:${hookEvent}`;
+}
+
+export function getSurfaceIdForService(serviceName: string): string {
+  return `service:${serviceName}`;
+}
+
+export function isSurfaceEnabled(
+  surfaceId: string,
+  overrides: Record<string, boolean> = {},
+): { enabled: boolean; reason?: string } {
+  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 type HookHandler<E, C, R> = (event: E, ctx: C) => R | Promise<R>;
+
+export 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> {
+  const check = isSurfaceEnabled(surfaceId);
+  if (check.enabled) {
+    return handler;
+  }
+  const reason = check.reason ?? 'surface not enabled';
+  return (_event: E, _ctx: C): R | Promise<R> => {
+    logger?.info?.(`[PD:surface-guard] SKIP ${surfaceId}: ${reason}`);
+    return undefined as R;
+  };
+}
+
+export function guardService<T extends OpenClawPluginService>(
+  surfaceId: string,
+  service: T,
+  logger?: { info?: (msg: string) => void; debug?: (msg: string) => void },
+): T | null {
+  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 };
+export type { PluginSurfaceEntry, MvpCategory };

package/src/hooks/prompt.ts

@@ -7,7 +7,8 @@ import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbat
 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';
+// 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';
@@ -25,7 +26,6 @@ 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,
@@ -703,10 +703,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)
@@ -1005,109 +1004,9 @@ ${empathySilenceConstraint}
     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: RegExp; tool: string }[] = [
-          { 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: string[] = [];
-          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: 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)}`);
-    }
-  }
+  // 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)
@@ -1130,15 +1029,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}
 `;
   }
 

package/src/i18n/commands.ts

@@ -34,8 +34,8 @@ export const commandDescriptions: Record<string, Record<SupportedLanguage, strin
     en: 'Research tool upgrade solutions'
   },
   'pd-thinking': {
-    zh: '管理思维模型 [status|propose|audit]',
-    en: 'Manage Thinking OS [status|propose|audit]'
+    zh: '管理思维模型 [status|propose|audit]（默认关闭，/pd-context thinking on 开启）',
+    en: 'Manage Thinking OS [status|propose|audit] (off by default, enable via /pd-context thinking on)'
   },
   'pd-daily': {
     zh: '配置并发送进化日报',

package/src/index.ts

@@ -62,6 +62,7 @@ import { computeRuntimeShadowTaskFingerprint, PD_LOCAL_PROFILES } from './utils/
 import type { WorkerProfile } from './core/model-deployment-registry.js';
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
 import { resolveWorkspaceDirFromApi } from './core/path-resolver.js';
+import { checkSurfaceGuard, guardHook, guardService } from './core/surface-guard.js';
 
 // Track started workspaces — one-time init + evolution worker per workspace
 const startedWorkspaces = new Set<string>();
@@ -190,12 +191,25 @@ const plugin = {
     }, 1000);
     healthCheckTimer.unref(); // Don't keep process alive for health check
 
+    // ── MVP Surface Guard (PRI-289): Verify surface classification ──
+    const surfaceGuard = checkSurfaceGuard();
+    if (!surfaceGuard.passed) {
+      for (const violation of surfaceGuard.violations) {
+        api.logger.error(`[PD:surface-guard] VIOLATION: ${violation}`);
+      }
+    }
+    api.logger.info(`[PD:surface-guard] Core surfaces: ${surfaceGuard.enabledCoreSurfaces.join(', ')}`);
+    api.logger.info(`[PD:surface-guard] Disabled non-core surfaces: ${surfaceGuard.disabledNonCoreSurfaces.length}`);
+    for (const warning of surfaceGuard.warnings) {
+      api.logger.warn(`[PD:surface-guard] ${warning}`);
+    }
+
     const language = (api.pluginConfig?.language as string) || 'en';
 
     // ── Hook: Prompt Building ──
     api.on(
       'before_prompt_build',
-      async (event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext): Promise<PluginHookBeforePromptBuildResult | void> => {
+      guardHook('hook:before_prompt_build', api.logger, async (event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext): Promise<PluginHookBeforePromptBuildResult | void> => {
         const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'before_prompt_build');
         if (!workspaceDir) {
           api.logger.error(
@@ -251,13 +265,13 @@ const plugin = {
           });
           api.logger.error(`[PD] Error in before_prompt_build: ${String(err)}`);
         }
-      }
+      })
     );
 
     // ── Hook: Security Gate ──
     api.on(
       'before_tool_call',
-      (event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext): PluginHookBeforeToolCallResult | void => {
+      guardHook('hook:before_tool_call', api.logger, (event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext): PluginHookBeforeToolCallResult | void => {
         const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'before_tool_call');
         if (!workspaceDir) {
           api.logger.error(
@@ -286,13 +300,13 @@ const plugin = {
           }, { flushImmediately: true });
           api.logger.error(`[PD] Error in before_tool_call: ${String(err)}`);
         }
-      }
+      })
     );
 
     // ── Hook: Pain & Trust ──
     api.on(
       'after_tool_call',
-      (event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext): void => {
+      guardHook('hook:after_tool_call', api.logger, (event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext): void => {
         const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'after_tool_call');
         if (!workspaceDir) {
           api.logger.error(
@@ -319,13 +333,13 @@ const plugin = {
           }, { flushImmediately: true });
           api.logger.error(`[PD:EmpathyObserver] Error in after_tool_call: ${String(err)}`);
         }
-      }
+      })
     );
 
     // ── Hook: LLM Analysis ──
     api.on(
       'llm_output',
-      (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext): void => {
+      guardHook('hook:llm_output', api.logger, (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext): void => {
         const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'llm_output');
         if (!workspaceDir) {
           api.logger.error(
@@ -352,14 +366,14 @@ const plugin = {
           });
           api.logger.error(`[PD] Error in llm_output: ${String(err)}`);
         }
-      }
+      })
     );
 
     // ── Hook: Trajectory Collection (Behavior Evolution Phase 0) ──
     // Note: after_tool_call and llm_output are safe to collect
     api.on(
       'after_tool_call',
-      (event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext): void => {
+      guardHook('hook:after_tool_call.trajectory', api.logger, (event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext): void => {
         try {
           const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'trajectory.after_tool_call');
           if (!workspaceDir) return;
@@ -368,12 +382,12 @@ const plugin = {
         } catch (_err) {
           // Non-critical: don't log, just skip
         }
-      }
+      })
     );
 
     api.on(
       'llm_output',
-      (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext): void => {
+      guardHook('hook:llm_output.trajectory', api.logger, (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext): void => {
         try {
           const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'trajectory.llm_output');
           if (!workspaceDir) return;
@@ -382,14 +396,14 @@ const plugin = {
         } catch (_err) {
           // Non-critical: don't log, just skip
         }
-      }
+      })
     );
 
     // ── Hook: Subagent Loop Closure ──
     api.on(
       'subagent_spawning',
        
-      (event: PluginHookSubagentSpawningEvent, _ctx: PluginHookSubagentContext): void | PluginHookSubagentSpawningResult => {
+      guardHook('hook:subagent_spawning', api.logger, (event: PluginHookSubagentSpawningEvent, _ctx: PluginHookSubagentContext): void | PluginHookSubagentSpawningResult => {
         try {
           // FIX (B): Never fall back to '.' — fail-fast with ERROR log if workspaceDir cannot be resolved.
           // For subagent hooks, we use event.agentId as the target agent for workspace resolution.
@@ -428,12 +442,12 @@ const plugin = {
           api.logger.error(`[PD] Error in subagent_spawning shadow routing: ${String(err)}`);
           return { status: 'ok' }; // Don't block spawn on shadow observation errors
         }
-      }
+      })
     );
 
     api.on(
       'subagent_ended',
-      (event: PluginHookSubagentEndedEvent, ctx: PluginHookSubagentContext): void => {
+      guardHook('hook:subagent_ended', api.logger, (event: PluginHookSubagentEndedEvent, ctx: PluginHookSubagentContext): void => {
         try {
           // FIX (B): Never fall back to '.' — fail-fast with ERROR log if workspaceDir cannot be resolved.
           const workspaceDir = resolveWorkspaceDirFromApi(api, undefined);
@@ -465,11 +479,11 @@ const plugin = {
         } catch (err) {
           api.logger.error(`[PD] Error in subagent_ended: ${String(err)}`);
         }
-      }
+      })
     );
 
     // ── Hook: Lifecycle ──
-    api.on('before_reset', (event: PluginHookBeforeResetEvent, ctx: PluginHookAgentContext) => {
+    api.on('before_reset', guardHook('hook:before_reset', api.logger, (event: PluginHookBeforeResetEvent, ctx: PluginHookAgentContext) => {
       const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'before_reset');
       if (!workspaceDir) {
         api.logger.error(
@@ -480,9 +494,9 @@ const plugin = {
         return;
       }
       return handleBeforeReset(event, { ...ctx, workspaceDir });
-    });
+    }));
     
-    api.on('before_compaction', (event: PluginHookBeforeCompactionEvent, ctx: PluginHookAgentContext) => {
+    api.on('before_compaction', guardHook('hook:before_compaction', api.logger, (event: PluginHookBeforeCompactionEvent, ctx: PluginHookAgentContext) => {
       const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'before_compaction');
       if (!workspaceDir) {
         api.logger.error(
@@ -493,9 +507,9 @@ const plugin = {
         return;
       }
       return handleBeforeCompaction(event, { ...ctx, workspaceDir });
-    });
+    }));
     
-    api.on('after_compaction', (event: PluginHookAfterCompactionEvent, ctx: PluginHookAgentContext) => {
+    api.on('after_compaction', guardHook('hook:after_compaction', api.logger, (event: PluginHookAfterCompactionEvent, ctx: PluginHookAgentContext) => {
       const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'after_compaction');
       if (!workspaceDir) {
         api.logger.error(
@@ -506,17 +520,21 @@ const plugin = {
         return;
       }
       return handleAfterCompaction(event, { ...ctx, workspaceDir });
-    });
+    }));
 
     // ── Service: Background Evolution Worker ──
     try {
       EvolutionWorkerService.api = api;
-      api.registerService(EvolutionWorkerService);
-      api.registerService(TrajectoryService);
-      api.registerService(PDTaskService);
-      api.registerService(CentralSyncService);
+      const guardedEvolutionWorker = guardService('service:evolution-worker', EvolutionWorkerService, api.logger);
+      if (guardedEvolutionWorker) api.registerService(guardedEvolutionWorker);
+      const guardedTrajectory = guardService('service:trajectory', TrajectoryService, api.logger);
+      if (guardedTrajectory) api.registerService(guardedTrajectory);
+      const guardedPdTask = guardService('service:pd-task', PDTaskService, api.logger);
+      if (guardedPdTask) api.registerService(guardedPdTask);
+      const guardedCentralSync = guardService('service:central-sync', CentralSyncService, api.logger);
+      if (guardedCentralSync) api.registerService(guardedCentralSync);
     } catch (err) {
-      api.logger.error(`[PD] Failed to register EvolutionWorkerService: ${String(err)}`);
+      api.logger.error(`[PD] Failed to register services: ${String(err)}`);
     }
 
     // ── Slash Commands ──

package/src/types.ts

@@ -37,13 +37,13 @@ export interface ContextInjectionConfig {
 
 /**
  * Default context injection configuration
- * Based on user requirements:
+ * Based on MVP-first strategy (ADR-0014):
  * - principles: always on (not configurable)
- * - thinkingOs: true (can be turned off)
+ * - thinkingOs: false by default (MVP-Quiet, user can opt-in via /pd-context)
  * - projectFocus: 'off' (default closed, user can enable)
  */
 export const defaultContextConfig: ContextInjectionConfig = {
-  thinkingOs: true,
+  thinkingOs: false,
   projectFocus: 'off',
   evolutionContext: {
     enabled: true,

package/tests/core-anti-growth.test.ts

@@ -123,6 +123,7 @@ describe('PRI-212 plugin core anti-growth guard', () => {
     'evolution-engine.ts',
     'runtime-v2-prompt-activation-reader.ts',
     'workspace-guidance-migrator.ts',
+    'surface-guard.ts',
   ] as const;
 
   // Category 6: Test files