@soleri/core 2.1.0 → 2.4.0

package/src/__tests__/brain-intelligence.test.ts

@@ -431,6 +431,41 @@ describe('BrainIntelligence', () => {
     expect(result.failed).toContain('non-existent');
   });
 
+  it('should gate promote through governance when strict preset', () => {
+    // Create a brain session and extract proposals
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'gov-promo-1',
+      toolsUsed: ['w', 'w', 'w'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'gov-promo-1' });
+    runtime.brainIntelligence.extractKnowledge('gov-promo-1');
+
+    const proposals = runtime.brainIntelligence.getProposals({ sessionId: 'gov-promo-1' });
+    expect(proposals.length).toBeGreaterThan(0);
+
+    // Apply strict preset — requireReview: true
+    runtime.governance.applyPreset('.', 'strict', 'test');
+
+    const result = runtime.brainIntelligence.promoteProposals(
+      [proposals[0].id],
+      runtime.governance,
+      '.',
+    );
+
+    // Should be gated, not promoted
+    expect(result.promoted).toBe(0);
+    expect(result.gated.length).toBe(1);
+    expect(result.gated[0].action).toBe('propose');
+
+    // Entry should NOT be in vault
+    expect(runtime.vault.get(`proposal-${proposals[0].id}`)).toBeNull();
+
+    // But should be in governance proposals
+    const pending = runtime.governance.listPendingProposals('.');
+    expect(pending.some((p) => p.source === 'brain-promote')).toBe(true);
+  });
+
   // ─── Build Intelligence ────────────────────────────────────────
 
   it('should build intelligence pipeline', () => {
@@ -557,6 +592,7 @@ describe('BrainIntelligence', () => {
           filesModified: [],
           planId: null,
           planOutcome: null,
+          extractedAt: null,
         },
       ],
       proposals: [],
@@ -609,6 +645,7 @@ describe('BrainIntelligence', () => {
           filesModified: [],
           planId: null,
           planOutcome: null,
+          extractedAt: null,
         },
       ],
       proposals: [],
@@ -620,4 +657,172 @@ describe('BrainIntelligence', () => {
     const result = runtime.brainIntelligence.importData(data);
     expect(result.imported.sessions).toBe(0); // Duplicate ignored
   });
+
+  // ─── Auto-extraction on session end ─────────────────────────
+
+  it('should auto-extract when session ends with tools used', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'auto-1',
+      domain: 'testing',
+      toolsUsed: ['search', 'search', 'search'],
+    });
+    const session = runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'auto-1',
+    });
+    // extractedAt should be set automatically
+    expect(session.extractedAt).not.toBeNull();
+  });
+
+  it('should not auto-extract when session has no signal', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'auto-2',
+    });
+    const session = runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'auto-2',
+    });
+    // No tools, no files, no plan — should not extract
+    expect(session.extractedAt).toBeNull();
+  });
+
+  it('should auto-extract when session has a plan', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'auto-3',
+      planId: 'plan-123',
+    });
+    const session = runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'auto-3',
+      planOutcome: 'completed',
+    });
+    expect(session.extractedAt).not.toBeNull();
+  });
+
+  // ─── extractedAt Tracking ──────────────────────────────────
+
+  it('should set extractedAt when extractKnowledge is called manually', () => {
+    // Use a session with no tools/files/plan so auto-extraction doesn't fire
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'ext-1',
+      domain: 'testing',
+    });
+    runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'ext-1',
+    });
+
+    // Before manual extraction, extractedAt should be null (no auto-extract — no signal)
+    const ctx = runtime.brainIntelligence.getSessionContext(10);
+    const before = ctx.recentSessions.find((s) => s.id === 'ext-1');
+    expect(before?.extractedAt).toBeNull();
+
+    // Manual extract
+    runtime.brainIntelligence.extractKnowledge('ext-1');
+
+    // After extraction, extractedAt should be set
+    const ctx2 = runtime.brainIntelligence.getSessionContext(10);
+    const after = ctx2.recentSessions.find((s) => s.id === 'ext-1');
+    expect(after?.extractedAt).not.toBeNull();
+  });
+
+  // ─── resetExtracted ────────────────────────────────────────
+
+  it('should reset extractedAt for a specific session', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reset-1',
+      toolsUsed: ['a', 'a', 'a'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reset-1' });
+    runtime.brainIntelligence.extractKnowledge('reset-1');
+
+    const result = runtime.brainIntelligence.resetExtracted({ sessionId: 'reset-1' });
+    expect(result.reset).toBe(1);
+
+    const ctx = runtime.brainIntelligence.getSessionContext(10);
+    const session = ctx.recentSessions.find((s) => s.id === 'reset-1');
+    expect(session?.extractedAt).toBeNull();
+  });
+
+  it('should reset all extracted sessions', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reset-a',
+      toolsUsed: ['a', 'a', 'a'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reset-a' });
+    runtime.brainIntelligence.extractKnowledge('reset-a');
+
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reset-b',
+      toolsUsed: ['b', 'b', 'b'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reset-b' });
+    runtime.brainIntelligence.extractKnowledge('reset-b');
+
+    const result = runtime.brainIntelligence.resetExtracted({ all: true });
+    expect(result.reset).toBe(2);
+  });
+
+  it('should return 0 when nothing to reset', () => {
+    const result = runtime.brainIntelligence.resetExtracted({ all: true });
+    expect(result.reset).toBe(0);
+  });
+
+  it('should return 0 when no filter is provided', () => {
+    const result = runtime.brainIntelligence.resetExtracted();
+    expect(result.reset).toBe(0);
+  });
+
+  it('should allow re-extraction after reset', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reext-1',
+      toolsUsed: ['search', 'search', 'search'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reext-1' });
+
+    const first = runtime.brainIntelligence.extractKnowledge('reext-1');
+    expect(first.proposals.length).toBeGreaterThan(0);
+
+    runtime.brainIntelligence.resetExtracted({ sessionId: 'reext-1' });
+
+    const second = runtime.brainIntelligence.extractKnowledge('reext-1');
+    expect(second.proposals.length).toBeGreaterThan(0);
+  });
+
+  // ─── computeStrengths with modified feedback ───────────────
+
+  it('should weight modified feedback at 0.5 in computeStrengths', () => {
+    // Seed an entry for feedback to reference
+    runtime.vault.seed([
+      {
+        id: 'str-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Strength test pattern',
+        severity: 'warning',
+        description: 'Testing strength computation with modified feedback.',
+        tags: ['test'],
+      },
+    ]);
+
+    // Record feedback: 1 accepted, 1 modified, 1 failed
+    runtime.brain.recordFeedback({ query: 'q1', entryId: 'str-1', action: 'accepted' });
+    runtime.brain.recordFeedback({ query: 'q2', entryId: 'str-1', action: 'modified' });
+    runtime.brain.recordFeedback({ query: 'q3', entryId: 'str-1', action: 'failed' });
+
+    const strengths = runtime.brainIntelligence.computeStrengths();
+    const s = strengths.find((p) => p.pattern === 'Strength test pattern');
+    expect(s).toBeDefined();
+
+    // successRate = (1 + 0.5) / (3 - 1) = 1.5/2 = 0.75
+    expect(s!.successRate).toBeCloseTo(0.75, 2);
+  });
 });

package/src/__tests__/brain.test.ts

@@ -741,6 +741,137 @@ describe('Brain', () => {
     });
   });
 
+  // ─── Enhanced Feedback ─────────────────────────────────────
+
+  describe('enhanced feedback', () => {
+    beforeEach(() => {
+      vault.seed([makeEntry({ id: 'fb-1', title: 'Feedback test pattern', tags: ['feedback'] })]);
+      brain = new Brain(vault);
+    });
+
+    it('should accept legacy 3-arg form (backward compat)', () => {
+      brain.recordFeedback('test query', 'fb-1', 'accepted');
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(1);
+      expect(stats.byAction['accepted']).toBe(1);
+    });
+
+    it('should accept FeedbackInput and return FeedbackEntry', () => {
+      const entry = brain.recordFeedback({
+        query: 'test query',
+        entryId: 'fb-1',
+        action: 'modified',
+        source: 'recommendation',
+        confidence: 0.85,
+        duration: 1200,
+        reason: 'adjusted wording',
+      });
+      expect(entry).toBeDefined();
+      expect(entry.action).toBe('modified');
+      expect(entry.source).toBe('recommendation');
+      expect(entry.confidence).toBe(0.85);
+      expect(entry.duration).toBe(1200);
+      expect(entry.reason).toBe('adjusted wording');
+      expect(entry.id).toBeGreaterThan(0);
+    });
+
+    it('should accept modified and failed action types', () => {
+      brain.recordFeedback({ query: 'q1', entryId: 'fb-1', action: 'modified' });
+      brain.recordFeedback({ query: 'q2', entryId: 'fb-1', action: 'failed' });
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(2);
+      expect(stats.byAction['modified']).toBe(1);
+      expect(stats.byAction['failed']).toBe(1);
+    });
+
+    it('should use default source and confidence when not provided', () => {
+      const entry = brain.recordFeedback({ query: 'q1', entryId: 'fb-1', action: 'accepted' });
+      expect(entry.source).toBe('search');
+      expect(entry.confidence).toBe(0.6);
+    });
+  });
+
+  // ─── Feedback Stats ───────────────────────────────────────
+
+  describe('getFeedbackStats', () => {
+    beforeEach(() => {
+      vault.seed([makeEntry({ id: 'fs-1', tags: ['stats'] })]);
+      brain = new Brain(vault);
+    });
+
+    it('should return zero stats on empty feedback', () => {
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(0);
+      expect(stats.acceptanceRate).toBe(0);
+      expect(stats.averageConfidence).toBe(0);
+    });
+
+    it('should compute acceptance rate correctly', () => {
+      brain.recordFeedback('q1', 'fs-1', 'accepted');
+      brain.recordFeedback('q2', 'fs-1', 'dismissed');
+      brain.recordFeedback('q3', 'fs-1', 'accepted');
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(3);
+      expect(stats.acceptanceRate).toBeCloseTo(2 / 3, 2);
+    });
+
+    it('should group by action and source', () => {
+      brain.recordFeedback({ query: 'q1', entryId: 'fs-1', action: 'accepted', source: 'search' });
+      brain.recordFeedback({
+        query: 'q2',
+        entryId: 'fs-1',
+        action: 'modified',
+        source: 'recommendation',
+      });
+      brain.recordFeedback({
+        query: 'q3',
+        entryId: 'fs-1',
+        action: 'failed',
+        source: 'tool-execution',
+      });
+      const stats = brain.getFeedbackStats();
+      expect(stats.byAction['accepted']).toBe(1);
+      expect(stats.byAction['modified']).toBe(1);
+      expect(stats.byAction['failed']).toBe(1);
+      expect(stats.bySource['search']).toBe(1);
+      expect(stats.bySource['recommendation']).toBe(1);
+      expect(stats.bySource['tool-execution']).toBe(1);
+    });
+
+    it('should compute average confidence', () => {
+      brain.recordFeedback({ query: 'q1', entryId: 'fs-1', action: 'accepted', confidence: 0.9 });
+      brain.recordFeedback({ query: 'q2', entryId: 'fs-1', action: 'dismissed', confidence: 0.3 });
+      const stats = brain.getFeedbackStats();
+      expect(stats.averageConfidence).toBeCloseTo(0.6, 2);
+    });
+  });
+
+  // ─── Recompute Weights with Modified/Failed ──────────────
+
+  describe('recomputeWeights with modified/failed', () => {
+    beforeEach(() => {
+      vault.seed([makeEntry({ id: 'rw-1', tags: ['weights'] })]);
+      brain = new Brain(vault);
+    });
+
+    it('should exclude failed from weight computation', () => {
+      // Add enough feedback to exceed threshold (30)
+      for (let i = 0; i < 20; i++) {
+        brain.recordFeedback('q', 'rw-1', 'accepted');
+      }
+      for (let i = 0; i < 10; i++) {
+        brain.recordFeedback({ query: 'q', entryId: 'rw-1', action: 'failed' });
+      }
+      // Failed entries should not count toward total for weight adaptation
+      // 20 accepted out of 20 relevant = 100% accept rate
+      const stats = brain.getStats();
+      // Weights should have adapted since we have 30+ total but only 20 non-failed
+      // (threshold is 30, total is 30, but only 20 are non-failed so threshold not met)
+      // The recomputeWeights() counts non-failed, which is 20 < 30, so weights stay default
+      expect(stats.weights.semantic).toBeCloseTo(0.4, 2);
+    });
+  });
+
   // ─── Graceful Degradation ───────────────────────────────────
 
   describe('graceful degradation', () => {