principles-disciple 1.76.0 → 1.78.0

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);
+  });
+});