principles-disciple 1.77.0 → 1.79.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.79.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.77.0",
+  "version": "1.79.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/runtime-v2-prompt-activation-reader.ts

@@ -1,23 +1,11 @@
 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';
-import type { ActivationStatusRecord, EffectiveFeatureFlags } from '@principles/core/runtime-v2';
+import { SqliteConnection, SqliteActivationStateStore, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS, filterPromptActivations, resolvePrincipleFromArtifact } from '@principles/core/runtime-v2';
+import type { EffectiveFeatureFlags, ActivatedPrinciple, PromptActivationReaderResult } from '@principles/core/runtime-v2';
 
-export 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';
-}
+export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
+export type { ActivatedPrinciple, PromptActivationReaderResult };
 
 export interface PromptActivationReaderDeps {
   logger?: { warn?: (msg: string) => void; info?: (msg: string) => void; error?: (msg: string) => void };
@@ -54,14 +42,29 @@ export class PromptActivationReader {
       sqliteConn = new SqliteConnection(this.workspaceDir);
       const store = new SqliteActivationStateStore(sqliteConn);
 
-      const activations = await store.listPromptActivations();
+      const allActivations = await store.listPromptActivations();
+      const promptActivations = filterPromptActivations(allActivations);
+
+      for (const activation of promptActivations) {
+        let artifactRow: unknown | null;
+        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;
+        }
 
-      for (const activation of activations) {
-        if (activation.channel !== 'prompt' || activation.action !== 'prompt_activate') {
+        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);
         } else {
@@ -85,6 +88,21 @@ export class PromptActivationReader {
     return { principles, warnings, source: 'runtime_v2' };
   }
 
+  private queryArtifactRow(sqliteConn: SqliteConnection, artifactId: string): unknown | null {
+    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`);
+    }
+  }
+
   private loadFeatureFlags(): EffectiveFeatureFlags {
     const configPath = path.join(this.workspaceDir, '.pd', 'feature-flags.yaml');
 
@@ -141,91 +159,4 @@ export class PromptActivationReader {
     }
     return result;
   }
-
-  private resolvePrincipleFromActivation(
-    sqliteConn: SqliteConnection,
-    activation: ActivationStatusRecord,
-  ): { ok: true; principle: ActivatedPrinciple } | { ok: false; warning: string } {
-    const db = sqliteConn.getDb();
-
-    let contentJson: string;
-
-    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: unknown;
-    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/src/hooks/prompt.ts

@@ -7,13 +7,14 @@ 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';
-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,
@@ -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)
@@ -899,20 +898,12 @@ ${heartbeatChecklist}
     dedupedV2 = v2Result.principles.filter((p) => !legacyActiveIds.has(p.principleId));
 
     if (dedupedV2.length > 0) {
-      let remaining = RUNTIME_V2_PRINCIPLE_BUDGET;
-      const lines: string[] = [];
-      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');
     }
@@ -985,129 +976,13 @@ ${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: string[] = [];
-    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');
+    const directiveText = renderPrinciplesToDirectives(dedupedV2, runtimeV2PrincipleIds, escapeXml);
+    prependSystemContext += directiveText;
   }
 
-  // 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 +1005,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);
+  });
+});