principles-disciple 1.77.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.77.0",
+  "version": "1.78.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.77.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/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/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/hooks/prompt-characterization.test.ts

@@ -188,10 +188,13 @@ function makeCtx(overrides: {
   } as unknown as Parameters<typeof import('../../src/hooks/prompt.js').handleBeforePromptBuild>[1];
 }
 
-// ─── Tests: Attitude Directive (GFI thresholds) ───────────────────────────
+// ─── Tests: Attitude Directive removed (PRI-291 MVP diet) ───────────────
+// Attitude/personality prompt text was removed per PRI-291.
+// GFI scoring (trackFriction) and empathy pain emission remain active.
+// These tests verify that attitude text no longer appears in prompts.
 
-describe('Attitude directive — GFI thresholds', () => {
-  // Ensure appendParts is non-empty so attitudeDirective is included in appendSystemContext.
+describe('Attitude/personality directive — removed from prompt (PRI-291)', () => {
+  // Ensure appendParts is non-empty so we can verify absence
   beforeEach(async () => {
     const { WorkspaceContext } = await import('../../src/core/workspace-context.js');
     (WorkspaceContext.fromHookContext as ReturnType<typeof vi.fn>).mockReturnValueOnce({
@@ -209,59 +212,42 @@ describe('Attitude directive — GFI thresholds', () => {
     });
   });
 
-  it('GFI >= 70 injects HUMBLE_RECOVERY mode', async () => {
+  it('GFI >= 70 does NOT inject HUMBLE_RECOVERY mode', async () => {
     setSessionGfi(75);
     const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
     const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionGfi: 75 }));
 
-    expect(result?.appendSystemContext).toContain('HUMBLE_RECOVERY');
-    expect(result?.appendSystemContext).toContain('GFI: 75');
+    const combined = (result?.prependSystemContext ?? '') + (result?.appendSystemContext ?? '');
+    expect(combined).not.toContain('HUMBLE_RECOVERY');
   });
 
-  it('GFI >= 70 injects HUMBLE_RECOVERY mode at boundary (70 exactly)', async () => {
-    setSessionGfi(70);
-    const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
-    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionGfi: 70 }));
-
-    expect(result?.appendSystemContext).toContain('HUMBLE_RECOVERY');
-  });
-
-  it('GFI >= 40 and < 70 injects CONCILIATORY mode', async () => {
+  it('GFI >= 40 does NOT inject CONCILIATORY mode', async () => {
     setSessionGfi(50);
     const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
     const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionGfi: 50 }));
 
-    expect(result?.appendSystemContext).toContain('CONCILIATORY');
-    expect(result?.appendSystemContext).toContain('GFI: 50');
+    const combined = (result?.prependSystemContext ?? '') + (result?.appendSystemContext ?? '');
+    expect(combined).not.toContain('CONCILIATORY');
   });
 
-  it('GFI >= 40 and < 70 injects CONCILIATORY mode at boundary (40 exactly)', async () => {
-    setSessionGfi(40);
-    const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
-    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionGfi: 40 }));
-
-    expect(result?.appendSystemContext).toContain('CONCILIATORY');
-  });
-
-  it('GFI < 40 injects EFFICIENT mode', async () => {
+  it('GFI < 40 does NOT inject EFFICIENT mode', async () => {
     setSessionGfi(10);
     const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
     const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionGfi: 10 }));
 
-    expect(result?.appendSystemContext).toContain('EFFICIENT');
-    expect(result?.appendSystemContext).toContain('GFI: 10');
+    const combined = (result?.prependSystemContext ?? '') + (result?.appendSystemContext ?? '');
+    expect(combined).not.toContain('EFFICIENT');
   });
 
-  it('GFI = 0 (no session) falls back to 0 and injects EFFICIENT', async () => {
-    setSessionGfi(0);
-    const { getSession } = await import('../../src/core/session-tracker.js');
-    // Override to return undefined (no session found)
-    (getSession as ReturnType<typeof vi.fn>).mockReturnValueOnce(undefined);
-
+  it('no "Spicy Evolver" persona text appears in prompt', async () => {
+    setSessionGfi(20);
     const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
-    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionId: 'no-such-session' }));
+    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx({ sessionGfi: 20 }));
 
-    expect(result?.appendSystemContext).toContain('EFFICIENT');
+    const combined = (result?.prependSystemContext ?? '') + (result?.appendSystemContext ?? '');
+    expect(combined).not.toContain('Spicy Evolver');
+    expect(combined).not.toContain('despise entropy');
+    expect(combined).not.toContain('evolve through pain');
   });
 });
 

package/tests/hooks/prompt-diet.test.ts

@@ -0,0 +1,343 @@
+/**
+ * Prompt diet tests — PRI-291
+ *
+ * Verifies that the default prompt contains only MVP-required sections
+ * and does NOT contain sections removed/default-disabled by the MVP diet.
+ *
+ * Acceptance criteria covered:
+ * 1. Default prompt does NOT contain Thinking OS text
+ * 2. Default prompt does NOT contain <routing_guidance>
+ * 3. Default prompt does NOT contain GFI attitude/personality directive text
+ * 4. Runtime V2 activation still injects validated directives into prependSystemContext
+ * 5. runtime_v2_prompt_activations_injected event still emits
+ * 6. GFI scoring/empathy evidence path still records friction and can emit pain
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// ─── Mock dependencies ───────────────────────────────────────────────────────
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  process.env.PD_LEGACY_PROMPT_DIAGNOSTICIAN_ENABLED = 'true';
+});
+
+afterEach(() => {
+  process.env.PD_LEGACY_PROMPT_DIAGNOSTICIAN_ENABLED = '';
+});
+
+const mockGetPendingDiagnosticianTasks = vi.fn<(stateDir: string) => unknown[]>();
+
+vi.mock('../../src/core/diagnostician-task-store.js', async () => ({
+  getPendingDiagnosticianTasks: (...args: unknown[]) =>
+    mockGetPendingDiagnosticianTasks(...args),
+}));
+
+vi.mock('../../src/core/event-log.js', () => ({
+  EventLogService: {
+    get: vi.fn().mockReturnValue({
+      recordHeartbeatDiagnosis: vi.fn(),
+      recordRuntimeV2ActivationsInjected: vi.fn(),
+    }),
+  },
+}));
+
+vi.mock('../../src/core/workspace-context.js', () => {
+  const mockWctx = {
+    workspaceDir: '/fake/workspace',
+    stateDir: '/fake/state',
+    resolve: (key: string) => `/fake/${key}`,
+    trajectory: { recordSession: vi.fn(), recordUserTurn: vi.fn() },
+    config: { get: vi.fn() },
+    eventLog: {
+      recordRuntimeV2ActivationsInjected: vi.fn(),
+    },
+    evolutionReducer: {
+      getActivePrinciples: vi.fn().mockReturnValue([]),
+      getProbationPrinciples: vi.fn().mockReturnValue([]),
+    },
+  };
+  return {
+    WorkspaceContext: {
+      fromHookContext: vi.fn().mockReturnValue(mockWctx),
+      fromHookContextExplicit: vi.fn().mockReturnValue(mockWctx),
+    },
+  };
+});
+
+let sessionGfiValue = 20;
+vi.mock('../../src/core/session-tracker.js', () => ({
+  getSession: vi.fn().mockImplementation(() => ({ currentGfi: sessionGfiValue })),
+  resetFriction: vi.fn(),
+  trackFriction: vi.fn(),
+  setInjectedProbationIds: vi.fn(),
+  clearInjectedProbationIds: vi.fn(),
+  decayGfi: vi.fn(),
+  getGfiDecayElapsed: vi.fn().mockReturnValue(0),
+}));
+
+vi.mock('../../src/core/path-resolver.js', () => ({
+  PathResolver: { getExtensionRoot: vi.fn().mockReturnValue('/fake/extension') },
+}));
+
+vi.mock('../../src/core/principle-injection.js', () => ({
+  selectPrinciplesForInjection: vi.fn().mockReturnValue({
+    selected: [],
+    wasTruncated: false,
+    breakdown: { p0: 0, p1: 0, p2: 0 },
+    totalChars: 0,
+  }),
+  DEFAULT_PRINCIPLE_BUDGET: 3000,
+}));
+
+vi.mock('../../src/core/empathy-keyword-matcher.js', () => ({
+  matchEmpathyKeywords: vi.fn().mockReturnValue({ score: 0, matched: null, severity: 'none', matchedTerms: [] }),
+  loadKeywordStore: vi.fn().mockReturnValue({ terms: {}, stats: { totalHits: 0 } }),
+  saveKeywordStore: vi.fn(),
+  shouldTriggerOptimization: vi.fn().mockReturnValue(false),
+  getKeywordStoreSummary: vi.fn().mockReturnValue({ totalTerms: 0, highFalsePositiveTerms: [] }),
+}));
+
+vi.mock('../../src/core/empathy-types.js', () => ({
+  severityToPenalty: vi.fn().mockReturnValue(5),
+  DEFAULT_EMPATHY_KEYWORD_CONFIG: {},
+}));
+
+vi.mock('../../src/core/correction-cue-learner.js', () => ({
+  CorrectionCueLearner: {
+    get: vi.fn().mockReturnValue({
+      match: vi.fn().mockReturnValue({ matched: null, matchedTerms: [], confidence: 0 }),
+      recordHits: vi.fn(),
+      recordTruePositive: vi.fn(),
+      flush: vi.fn(),
+    }),
+  },
+}));
+
+vi.mock('../../src/core/focus-history.js', () => ({
+  extractSummary: vi.fn().mockReturnValue(''),
+  getHistoryVersions: vi.fn().mockResolvedValue([]),
+  parseWorkingMemorySection: vi.fn().mockReturnValue(null),
+  workingMemoryToInjection: vi.fn().mockReturnValue(''),
+  autoCompressFocus: vi.fn().mockReturnValue({ compressed: false, reason: 'not_needed' }),
+  safeReadCurrentFocus: vi.fn().mockReturnValue({ content: '', recovered: false, validationErrors: [] }),
+}));
+
+vi.mock('../../src/service/subagent-workflow/index.js', () => ({
+  EmpathyObserverWorkflowManager: vi.fn(),
+  empathyObserverWorkflowSpec: {},
+  isExpectedSubagentError: vi.fn().mockReturnValue(false),
+}));
+
+vi.mock('../../src/utils/subagent-probe.js', () => ({
+  isSubagentRuntimeAvailable: vi.fn().mockReturnValue(false),
+}));
+
+vi.mock('../../src/core/local-worker-routing.js', () => ({
+  classifyTask: vi.fn().mockReturnValue({
+    decision: 'stay_main',
+    classification: 'unknown',
+    reason: 'mocked',
+    blockers: [],
+  }),
+}));
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeMinimalEvent(overrides: {
+  trigger?: string;
+  sessionId?: string;
+} = {}) {
+  const { trigger = 'user', sessionId = 'test-session-diet' } = overrides;
+  return {
+    prompt: 'hello world',
+    messages: [],
+    trigger,
+    sessionId,
+  } as unknown as Parameters<typeof import('../../src/hooks/prompt.js').handleBeforePromptBuild>[0];
+}
+
+function makeCtx(overrides: {
+  sessionGfi?: number;
+  trigger?: string;
+  sessionId?: string;
+} = {}) {
+  const { sessionGfi = 20, trigger = 'user', sessionId = 'test-session-diet' } = overrides;
+  sessionGfiValue = sessionGfi;
+  return {
+    workspaceDir: '/fake/workspace',
+    trigger,
+    sessionId,
+    api: {
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      runtime: {},
+      config: {},
+    },
+  } as unknown as Parameters<typeof import('../../src/hooks/prompt.js').handleBeforePromptBuild>[1];
+}
+
+async function getPromptOutput(overrides: { sessionGfi?: number } = {}) {
+  const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
+  const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx(overrides));
+  return {
+    prepend: result?.prependSystemContext ?? '',
+    append: result?.appendSystemContext ?? '',
+    context: result?.prependContext ?? '',
+  };
+}
+
+// ─── Tests: MVP Diet — sections that must NOT appear by default ────────────
+
+describe('PRI-291 Prompt Diet: default prompt excludes non-MVP sections', () => {
+  it('default prompt does NOT contain Thinking OS text', async () => {
+    const { append } = await getPromptOutput();
+    expect(append).not.toContain('<thinking_os>');
+  });
+
+  it('default prompt does NOT contain <routing_guidance>', async () => {
+    const { append } = await getPromptOutput();
+    expect(append).not.toContain('<routing_guidance>');
+    expect(append).not.toContain('DELEGATION SUGGESTION');
+    expect(append).not.toContain('ROUTING GUIDANCE');
+  });
+
+  it('default prompt does NOT contain GFI attitude/personality text', async () => {
+    const { prepend, append } = await getPromptOutput();
+    const combined = prepend + append;
+    expect(combined).not.toContain('HUMBLE_RECOVERY');
+    expect(combined).not.toContain('CONCILIATORY');
+    expect(combined).not.toContain('EFFICIENT');
+    expect(combined).not.toContain('Spicy Evolver');
+    expect(combined).not.toContain('despise entropy');
+    expect(combined).not.toContain('evolve through pain');
+  });
+
+  it('default prompt does NOT contain <project_context> (default is off)', async () => {
+    const { append } = await getPromptOutput();
+    // project_context tag should not appear as a content block.
+    // Note: the EXECUTION RULES section may list it as a priority description,
+    // but the actual <project_context>...</project_context> content block must be absent.
+    const hasProjectContextBlock = append.includes('<project_context>\n');
+    expect(hasProjectContextBlock).toBe(false);
+  });
+
+  it('EXECUTION RULES does not list removed sections', async () => {
+    const { append } = await getPromptOutput();
+    // Only present when appendParts is non-empty (principles exist)
+    // But even when present, removed sections should not be listed
+    if (append.includes('EXECUTION RULES')) {
+      expect(append).not.toContain('<thinking_os>');
+      expect(append).not.toContain('<routing_guidance>');
+      expect(append).not.toContain('<reflection_log>');
+    }
+  });
+});
+
+// ─── Tests: MVP Diet — sections that MUST still appear ─────────────────────
+
+describe('PRI-291 Prompt Diet: MVP sections preserved', () => {
+  it('AGENT IDENTITY is still injected in prependSystemContext', async () => {
+    const { prepend } = await getPromptOutput();
+    expect(prepend).toContain('AGENT IDENTITY');
+  });
+
+  it('evolution principles can still be injected when active', async () => {
+    const { WorkspaceContext } = await import('../../src/core/workspace-context.js');
+    (WorkspaceContext.fromHookContext as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      workspaceDir: '/fake/workspace',
+      stateDir: '/fake/state',
+      resolve: (key: string) => `/fake/${key}`,
+      trajectory: { recordSession: vi.fn(), recordUserTurn: vi.fn() },
+      config: { get: vi.fn() },
+      eventLog: { recordRuntimeV2ActivationsInjected: vi.fn() },
+      evolutionReducer: {
+        getActivePrinciples: vi.fn().mockReturnValue([
+          { id: 'P1', text: 'Evolution principle still works' },
+        ]),
+        getProbationPrinciples: vi.fn().mockReturnValue([]),
+      },
+    });
+
+    const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
+    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx());
+
+    expect(result?.appendSystemContext).toContain('<evolution_principles>');
+    expect(result?.appendSystemContext).toContain('Evolution principle still works');
+  });
+
+  it('core principles can still be injected', async () => {
+    const { WorkspaceContext } = await import('../../src/core/workspace-context.js');
+    (WorkspaceContext.fromHookContext as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      workspaceDir: '/fake/workspace',
+      stateDir: '/fake/state',
+      resolve: (key: string) => `/fake/${key}`,
+      trajectory: { recordSession: vi.fn(), recordUserTurn: vi.fn() },
+      config: { get: vi.fn() },
+      eventLog: { recordRuntimeV2ActivationsInjected: vi.fn() },
+      evolutionReducer: {
+        getActivePrinciples: vi.fn().mockReturnValue([
+          { id: 'CP1', text: 'Core principle preserved' },
+        ]),
+        getProbationPrinciples: vi.fn().mockReturnValue([]),
+      },
+    });
+
+    const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
+    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx());
+
+    expect(result?.appendSystemContext).toContain('<core_principles>');
+  });
+
+  it('GFI scoring still runs — trackFriction called on empathy match', async () => {
+    const { matchEmpathyKeywords } = await import('../../src/core/empathy-keyword-matcher.js');
+    (matchEmpathyKeywords as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      score: 0.8,
+      matched: true,
+      severity: 'moderate',
+      matchedTerms: ['frustrated'],
+    });
+
+    const { WorkspaceContext } = await import('../../src/core/workspace-context.js');
+    (WorkspaceContext.fromHookContext as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      workspaceDir: '/fake/workspace',
+      stateDir: '/fake/state',
+      resolve: (key: string) => `/fake/${key}`,
+      trajectory: { recordSession: vi.fn(), recordUserTurn: vi.fn(), recordPainEvent: vi.fn() },
+      config: { get: vi.fn().mockImplementation((k: string) => {
+        if (k === 'thresholds.pain_trigger') return 40;
+        if (k === 'severity_thresholds.high') return 70;
+        if (k === 'language') return 'en';
+        return undefined;
+      }) },
+      eventLog: { recordPainSignal: vi.fn() },
+      evolutionReducer: {
+        getActivePrinciples: vi.fn().mockReturnValue([]),
+        getProbationPrinciples: vi.fn().mockReturnValue([]),
+      },
+    });
+
+    const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
+    const event = {
+      prompt: 'I am frustrated with this result',
+      messages: [{ role: 'user', content: 'I am frustrated' }],
+      trigger: 'user',
+      sessionId: 'gfi-test-session',
+    } as unknown as Parameters<typeof import('../../src/hooks/prompt.js').handleBeforePromptBuild>[0];
+
+    await handleBeforePromptBuild(event, makeCtx({ sessionGfi: 80 }));
+
+    const { trackFriction } = await import('../../src/core/session-tracker.js');
+    expect(trackFriction).toHaveBeenCalled();
+  });
+
+  it('size guard still works — total injection under 9000', async () => {
+    const { handleBeforePromptBuild } = await import('../../src/hooks/prompt.js');
+    const result = await handleBeforePromptBuild(makeMinimalEvent(), makeCtx());
+
+    const total =
+      (result?.prependSystemContext?.length ?? 0) +
+      (result?.prependContext?.length ?? 0) +
+      (result?.appendSystemContext?.length ?? 0);
+    expect(total).toBeLessThanOrEqual(9000);
+  });
+});