@soleri/core 9.0.4 → 9.3.0

package/src/agency/default-rules.test.ts

@@ -0,0 +1,236 @@
+/**
+ * Default Suggestion Rules — colocated contract tests.
+ *
+ * Validates each of the 6 built-in rules: condition triggers and generate output shape.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_SUGGESTION_RULES } from './default-rules.js';
+import type { SuggestionContext, Warning, SurfacedPattern } from './types.js';
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeContext(overrides?: Partial<SuggestionContext>): SuggestionContext {
+  return {
+    recentFiles: [],
+    pendingWarnings: [],
+    surfacedPatterns: [],
+    fileChangesProcessed: 0,
+    ...overrides,
+  };
+}
+
+function makeWarning(overrides?: Partial<Warning>): Warning {
+  return {
+    id: 'w-1',
+    file: '/test.ts',
+    severity: 'warning',
+    category: 'test',
+    message: 'test warning',
+    ...overrides,
+  };
+}
+
+function makePattern(overrides?: Partial<SurfacedPattern>): SurfacedPattern {
+  return {
+    entryId: 'p-1',
+    title: 'Test pattern',
+    domain: 'general',
+    relevance: 0.8,
+    trigger: '/test.ts',
+    ...overrides,
+  };
+}
+
+function findRule(name: string) {
+  return DEFAULT_SUGGESTION_RULES.find((r) => r.name === name)!;
+}
+
+describe('DEFAULT_SUGGESTION_RULES', () => {
+  it('exports exactly 6 rules', () => {
+    expect(DEFAULT_SUGGESTION_RULES).toHaveLength(6);
+  });
+
+  it('each rule has name, description, condition, and generate', () => {
+    for (const rule of DEFAULT_SUGGESTION_RULES) {
+      expect(typeof rule.name).toBe('string');
+      expect(typeof rule.description).toBe('string');
+      expect(typeof rule.condition).toBe('function');
+      expect(typeof rule.generate).toBe('function');
+    }
+  });
+
+  // ─── many-warnings ────────────────────────────────────────────────
+
+  describe('many-warnings', () => {
+    const rule = findRule('many-warnings');
+
+    it('fires when 5+ warnings pending', () => {
+      const warnings = Array.from({ length: 5 }, (_, i) => makeWarning({ id: `w-${i}` }));
+      expect(rule.condition(makeContext({ pendingWarnings: warnings }))).toBe(true);
+    });
+
+    it('does not fire with fewer than 5 warnings', () => {
+      expect(rule.condition(makeContext({ pendingWarnings: [makeWarning()] }))).toBe(false);
+    });
+
+    it('generates high priority suggestion with count in title', () => {
+      const warnings = Array.from({ length: 7 }, (_, i) => makeWarning({ id: `w-${i}` }));
+      const s = rule.generate(makeContext({ pendingWarnings: warnings }));
+      expect(s.rule).toBe('many-warnings');
+      expect(s.priority).toBe('high');
+      expect(s.title).toContain('7');
+    });
+  });
+
+  // ─── stale-patterns ───────────────────────────────────────────────
+
+  describe('stale-patterns', () => {
+    const rule = findRule('stale-patterns');
+
+    it('fires when no patterns surfaced after 20+ changes', () => {
+      expect(rule.condition(makeContext({ fileChangesProcessed: 21 }))).toBe(true);
+    });
+
+    it('does not fire with patterns present', () => {
+      expect(
+        rule.condition(
+          makeContext({
+            fileChangesProcessed: 30,
+            surfacedPatterns: [makePattern()],
+          }),
+        ),
+      ).toBe(false);
+    });
+
+    it('does not fire with few changes', () => {
+      expect(rule.condition(makeContext({ fileChangesProcessed: 5 }))).toBe(false);
+    });
+
+    it('generates medium priority suggestion', () => {
+      const s = rule.generate(makeContext({ fileChangesProcessed: 25 }));
+      expect(s.rule).toBe('stale-patterns');
+      expect(s.priority).toBe('medium');
+    });
+  });
+
+  // ─── high-activity-no-capture ─────────────────────────────────────
+
+  describe('high-activity-no-capture', () => {
+    const rule = findRule('high-activity-no-capture');
+
+    it('fires when 50+ changes and no patterns', () => {
+      expect(rule.condition(makeContext({ fileChangesProcessed: 51 }))).toBe(true);
+    });
+
+    it('does not fire with patterns', () => {
+      expect(
+        rule.condition(
+          makeContext({
+            fileChangesProcessed: 60,
+            surfacedPatterns: [makePattern()],
+          }),
+        ),
+      ).toBe(false);
+    });
+
+    it('does not fire with few changes', () => {
+      expect(rule.condition(makeContext({ fileChangesProcessed: 10 }))).toBe(false);
+    });
+
+    it('generates suggestion with change count', () => {
+      const s = rule.generate(makeContext({ fileChangesProcessed: 55 }));
+      expect(s.rule).toBe('high-activity-no-capture');
+      expect(s.priority).toBe('medium');
+      expect(s.description).toContain('55');
+    });
+  });
+
+  // ─── critical-warnings ────────────────────────────────────────────
+
+  describe('critical-warnings', () => {
+    const rule = findRule('critical-warnings');
+
+    it('fires when critical severity warnings exist', () => {
+      const ctx = makeContext({
+        pendingWarnings: [makeWarning({ severity: 'critical' })],
+      });
+      expect(rule.condition(ctx)).toBe(true);
+    });
+
+    it('does not fire with only non-critical warnings', () => {
+      const ctx = makeContext({
+        pendingWarnings: [makeWarning({ severity: 'warning' }), makeWarning({ severity: 'info' })],
+      });
+      expect(rule.condition(ctx)).toBe(false);
+    });
+
+    it('generates high priority with count and messages', () => {
+      const ctx = makeContext({
+        pendingWarnings: [
+          makeWarning({ severity: 'critical', message: 'sec issue' }),
+          makeWarning({ severity: 'critical', message: 'another issue' }),
+          makeWarning({ severity: 'warning', message: 'minor' }),
+        ],
+      });
+      const s = rule.generate(ctx);
+      expect(s.rule).toBe('critical-warnings');
+      expect(s.priority).toBe('high');
+      expect(s.title).toContain('2');
+      expect(s.description).toContain('sec issue');
+    });
+  });
+
+  // ─── pattern-surfaced ─────────────────────────────────────────────
+
+  describe('pattern-surfaced', () => {
+    const rule = findRule('pattern-surfaced');
+
+    it('fires when patterns are surfaced', () => {
+      expect(rule.condition(makeContext({ surfacedPatterns: [makePattern()] }))).toBe(true);
+    });
+
+    it('does not fire with empty patterns', () => {
+      expect(rule.condition(makeContext())).toBe(false);
+    });
+
+    it('generates low priority with pattern titles', () => {
+      const ctx = makeContext({
+        surfacedPatterns: [
+          makePattern({ title: 'React hooks', domain: 'react' }),
+          makePattern({ title: 'CSS Grid', domain: 'styling' }),
+        ],
+      });
+      const s = rule.generate(ctx);
+      expect(s.rule).toBe('pattern-surfaced');
+      expect(s.priority).toBe('low');
+      expect(s.description).toContain('React hooks');
+      expect(s.description).toContain('CSS Grid');
+    });
+  });
+
+  // ─── first-session ────────────────────────────────────────────────
+
+  describe('first-session', () => {
+    const rule = findRule('first-session');
+
+    it('fires on fresh state (0 changes, 0 warnings)', () => {
+      expect(rule.condition(makeContext())).toBe(true);
+    });
+
+    it('does not fire after changes processed', () => {
+      expect(rule.condition(makeContext({ fileChangesProcessed: 1 }))).toBe(false);
+    });
+
+    it('does not fire when warnings exist', () => {
+      expect(rule.condition(makeContext({ pendingWarnings: [makeWarning()] }))).toBe(false);
+    });
+
+    it('generates low priority welcome message', () => {
+      const s = rule.generate(makeContext());
+      expect(s.rule).toBe('first-session');
+      expect(s.priority).toBe('low');
+      expect(s.title).toContain('ready');
+    });
+  });
+});

package/src/{__tests__ → brain}/brain-intelligence.test.ts

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createAgentRuntime } from '../runtime/runtime.js';
 import type { AgentRuntime } from '../runtime/types.js';
-import type { BrainExportData } from '../brain/types.js';
+import type { BrainExportData } from './types.js';
 
 describe('BrainIntelligence', () => {
   let runtime: AgentRuntime;
@@ -367,17 +367,25 @@ describe('BrainIntelligence', () => {
   // ─── Proposals ─────────────────────────────────────────────────
 
   it('should list proposals', () => {
+    // Use plan_completed (confidence 0.65) — below auto-promote threshold (0.8)
     runtime.brainIntelligence.lifecycle({
       action: 'start',
       sessionId: 'prop-1',
-      toolsUsed: ['a', 'a', 'a'],
+      planId: 'plan-list-1',
+    });
+    runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'prop-1',
+      planId: 'plan-list-1',
+      planOutcome: 'completed',
     });
-    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'prop-1' });
-    runtime.brainIntelligence.extractKnowledge('prop-1');
 
     const proposals = runtime.brainIntelligence.getProposals();
     expect(proposals.length).toBeGreaterThan(0);
-    expect(proposals[0].promoted).toBe(false);
+    // plan_completed confidence is 0.65 — below auto-promote threshold
+    const planProposals = proposals.filter((p) => p.rule === 'plan_completed');
+    expect(planProposals.length).toBeGreaterThan(0);
+    expect(planProposals[0].promoted).toBe(false);
   });
 
   it('should filter proposals by session', () => {
@@ -404,15 +412,23 @@ describe('BrainIntelligence', () => {
   });
 
   it('should promote proposals to vault', () => {
+    // Use plan_completed (confidence 0.65) to avoid auto-promote (threshold 0.8)
     runtime.brainIntelligence.lifecycle({
       action: 'start',
       sessionId: 'promo-1',
-      toolsUsed: ['z', 'z', 'z'],
+      planId: 'plan-promo-1',
+    });
+    runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'promo-1',
+      planId: 'plan-promo-1',
+      planOutcome: 'completed',
     });
-    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'promo-1' });
-    runtime.brainIntelligence.extractKnowledge('promo-1');
 
-    const proposals = runtime.brainIntelligence.getProposals({ sessionId: 'promo-1' });
+    const proposals = runtime.brainIntelligence.getProposals({
+      sessionId: 'promo-1',
+      promoted: false,
+    });
     expect(proposals.length).toBeGreaterThan(0);
 
     const result = runtime.brainIntelligence.promoteProposals([proposals[0].id]);
@@ -432,16 +448,23 @@ describe('BrainIntelligence', () => {
   });
 
   it('should gate promote through governance when strict preset', () => {
-    // Create a brain session and extract proposals
+    // Use plan_completed (confidence 0.65) to avoid auto-promote (threshold 0.8)
     runtime.brainIntelligence.lifecycle({
       action: 'start',
       sessionId: 'gov-promo-1',
-      toolsUsed: ['w', 'w', 'w'],
+      planId: 'plan-gov-1',
+    });
+    runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'gov-promo-1',
+      planId: 'plan-gov-1',
+      planOutcome: 'completed',
     });
-    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'gov-promo-1' });
-    runtime.brainIntelligence.extractKnowledge('gov-promo-1');
 
-    const proposals = runtime.brainIntelligence.getProposals({ sessionId: 'gov-promo-1' });
+    const proposals = runtime.brainIntelligence.getProposals({
+      sessionId: 'gov-promo-1',
+      promoted: false,
+    });
     expect(proposals.length).toBeGreaterThan(0);
 
     // Apply strict preset — requireReview: true

package/src/{__tests__ → brain}/brain.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { Vault } from '../vault/vault.js';
-import { Brain } from '../brain/brain.js';
+import { Brain } from './brain.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 
 function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {

package/src/brain/intelligence.ts

@@ -10,6 +10,8 @@ import { randomUUID } from 'node:crypto';
 import type { Vault } from '../vault/vault.js';
 import type { Brain } from './brain.js';
 import type { PersistenceProvider } from '../persistence/types.js';
+import type { OperatorProfileStore } from '../operator/operator-profile.js';
+import { extractFromBrainStrengths } from '../operator/operator-signals.js';
 import type {
   PatternStrength,
   StrengthsQuery,
@@ -38,6 +40,10 @@ const EXTRACTION_TOOL_THRESHOLD = 3;
 const EXTRACTION_FILE_THRESHOLD = 3;
 const EXTRACTION_LONG_SESSION_MINUTES = 30;
 const EXTRACTION_HIGH_FEEDBACK_RATIO = 0.8;
+const AUTO_PROMOTE_THRESHOLD = 0.8;
+const AUTO_PROMOTE_PENDING_MIN = 0.4;
+const AUTO_BUILD_INTELLIGENCE_EVERY_N_SESSIONS = 3;
+const AUTO_BUILD_INTELLIGENCE_EVERY_N_FEEDBACK = 5;
 
 // ─── Class ──────────────────────────────────────────────────────────
 
@@ -45,6 +51,7 @@ export class BrainIntelligence {
   private vault: Vault;
   private brain: Brain;
   private provider: PersistenceProvider;
+  private operatorProfile: OperatorProfileStore | null = null;
 
   constructor(vault: Vault, brain: Brain) {
     this.vault = vault;
@@ -53,6 +60,11 @@ export class BrainIntelligence {
     this.initializeTables();
   }
 
+  /** Wire operator profile for automatic signal extraction. */
+  setOperatorProfile(profile: OperatorProfileStore): void {
+    this.operatorProfile = profile;
+  }
+
   // ─── Table Initialization ─────────────────────────────────────────
 
   private initializeTables(): void {
@@ -116,6 +128,12 @@ export class BrainIntelligence {
         last_activity TEXT NOT NULL DEFAULT (datetime('now')),
         updated_at TEXT NOT NULL DEFAULT (datetime('now'))
       );
+
+      CREATE TABLE IF NOT EXISTS brain_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
     `);
   }
 
@@ -177,6 +195,12 @@ export class BrainIntelligence {
    * Attempt auto-extraction after session end if the session has enough signal.
    * Gate: at least 1 tool used OR 1 file modified OR a plan was associated.
    * Silently skips if already extracted or insufficient data.
+   *
+   * After extraction, auto-promotes high-confidence proposals (>= 0.8) via
+   * enrichAndCapture() (which has built-in dedup). Proposals between 0.4-0.8
+   * are queued as pending. Below 0.4 are logged only.
+   *
+   * Also tracks completed sessions and auto-builds intelligence every N sessions.
    */
   private autoExtractIfReady(session: BrainSession): void {
     if (!session.endedAt) return;
@@ -188,12 +212,124 @@ export class BrainIntelligence {
     if (!hasSignal) return;
 
     try {
-      this.extractKnowledge(session.id);
+      const result = this.extractKnowledge(session.id);
+      this.autoPromoteProposals(result.proposals);
+    } catch {
+      // Non-critical — don't break session end
+    }
+
+    // Auto-build intelligence after N completed plan sessions
+    if (session.planOutcome === 'completed') {
+      this.maybeAutoBuildIntelligence();
+    }
+  }
+
+  /**
+   * Auto-promote high-confidence proposals via enrichAndCapture().
+   * Dedup in enrichAndCapture() handles novelty gating:
+   * - TF-IDF similarity >= 0.8 → blocked (near-duplicate)
+   * - Content-hash match → blocked (exact duplicate)
+   */
+  private autoPromoteProposals(proposals: KnowledgeProposal[]): void {
+    for (const p of proposals) {
+      if (p.confidence >= AUTO_PROMOTE_THRESHOLD) {
+        // High confidence — auto-promote through dedup pipeline
+        try {
+          const vaultType: 'pattern' | 'anti-pattern' | 'rule' =
+            p.type === 'anti-pattern' ? 'anti-pattern' : 'pattern';
+          const result = this.brain.enrichAndCapture({
+            id: `proposal-${p.id}`,
+            type: vaultType,
+            domain: 'brain-intelligence',
+            title: p.title,
+            severity: 'suggestion',
+            description: p.description,
+            tags: ['auto-extracted', 'auto-promoted', p.rule],
+          });
+          if (result.captured) {
+            this.provider.run('UPDATE brain_proposals SET promoted = 1 WHERE id = ?', [p.id]);
+          }
+          // If blocked by dedup, leave as unpromoted — that's correct behavior
+        } catch {
+          // Non-critical — proposal stays as pending
+        }
+      } else if (p.confidence < AUTO_PROMOTE_PENDING_MIN) {
+        // Low confidence — mark as not surfaceable (promoted = false is already default)
+        // Just log, don't surface in briefings
+      }
+      // Medium confidence (0.4-0.8) — stays as pending, surfaced in briefing
+    }
+  }
+
+  /**
+   * Track completed sessions and auto-trigger buildIntelligence() every N sessions.
+   */
+  private maybeAutoBuildIntelligence(): void {
+    try {
+      const row = this.provider.get<{ value: string }>(
+        "SELECT value FROM brain_metadata WHERE key = 'sessions_since_last_build'",
+      );
+      const current = row ? parseInt(row.value, 10) : 0;
+      const next = current + 1;
+
+      if (next >= AUTO_BUILD_INTELLIGENCE_EVERY_N_SESSIONS) {
+        this.buildIntelligence();
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_metadata (key, value, updated_at)
+           VALUES ('sessions_since_last_build', '0', datetime('now'))`,
+        );
+        // Reset feedback counter too — avoid double-trigger
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_metadata (key, value, updated_at)
+           VALUES ('feedback_since_last_build', '0', datetime('now'))`,
+        );
+      } else {
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_metadata (key, value, updated_at)
+           VALUES ('sessions_since_last_build', ?, datetime('now'))`,
+          [String(next)],
+        );
+      }
     } catch {
       // Non-critical — don't break session end
     }
   }
 
+  /**
+   * Auto-rebuild intelligence after N feedback entries accumulate.
+   * Called from facade after record_feedback / brain_feedback ops.
+   */
+  maybeAutoBuildOnFeedback(): void {
+    try {
+      const row = this.provider.get<{ value: string }>(
+        "SELECT value FROM brain_metadata WHERE key = 'feedback_since_last_build'",
+      );
+      const current = row ? parseInt(row.value, 10) : 0;
+      const next = current + 1;
+
+      if (next >= AUTO_BUILD_INTELLIGENCE_EVERY_N_FEEDBACK) {
+        this.buildIntelligence();
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_metadata (key, value, updated_at)
+           VALUES ('feedback_since_last_build', '0', datetime('now'))`,
+        );
+        // Reset session counter too — avoid double-trigger
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_metadata (key, value, updated_at)
+           VALUES ('sessions_since_last_build', '0', datetime('now'))`,
+        );
+      } else {
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_metadata (key, value, updated_at)
+           VALUES ('feedback_since_last_build', ?, datetime('now'))`,
+          [String(next)],
+        );
+      }
+    } catch {
+      // Non-critical — don't block feedback recording
+    }
+  }
+
   getSessionContext(limit = 10): SessionContext {
     const rows = this.provider.all<{
       id: string;
@@ -249,6 +385,24 @@ export class BrainIntelligence {
     return this.getSession(id);
   }
 
+  getSessionByPlanId(planId: string): BrainSession | null {
+    const row = this.provider.get<{
+      id: string;
+      started_at: string;
+      ended_at: string | null;
+      domain: string | null;
+      context: string | null;
+      tools_used: string;
+      files_modified: string;
+      plan_id: string | null;
+      plan_outcome: string | null;
+      extracted_at: string | null;
+    }>('SELECT * FROM brain_sessions WHERE plan_id = ? ORDER BY started_at DESC LIMIT 1', [planId]);
+
+    if (!row) return null;
+    return this.rowToSession(row);
+  }
+
   listSessions(query?: SessionListQuery): BrainSession[] {
     const conditions: string[] = [];
     const values: unknown[] = [];
@@ -595,19 +749,34 @@ export class BrainIntelligence {
       }
     }
 
-    // Rule 2: Multi-file edits (3+ files)
+    // Rule 2: Multi-file edits (3+ files sharing a common parent directory)
     if (session.filesModified.length >= EXTRACTION_FILE_THRESHOLD) {
-      rulesApplied.push('multi_file_edit');
-      proposals.push(
-        this.createProposal(sessionId, 'multi_file_edit', 'pattern', {
-          title: `Multi-file change pattern (${session.filesModified.length} files)`,
-          description: `Session modified ${session.filesModified.length} files: ${session.filesModified.slice(0, 5).join(', ')}${session.filesModified.length > 5 ? '...' : ''}. This may indicate an architectural pattern.`,
-          confidence: Math.min(0.8, 0.4 + session.filesModified.length * 0.05),
-        }),
+      // Group files by parent directory to filter noise
+      const dirGroups = new Map<string, string[]>();
+      for (const f of session.filesModified) {
+        const dir = f.includes('/') ? f.slice(0, f.lastIndexOf('/')) : '.';
+        const list = dirGroups.get(dir) ?? [];
+        list.push(f);
+        dirGroups.set(dir, list);
+      }
+      // Only fire if at least 3 files share a common parent directory
+      const significantDirs = [...dirGroups.entries()].filter(
+        ([, files]) => files.length >= EXTRACTION_FILE_THRESHOLD,
       );
+      if (significantDirs.length > 0) {
+        const [topDir, topFiles] = significantDirs.sort((a, b) => b[1].length - a[1].length)[0];
+        rulesApplied.push('multi_file_edit');
+        proposals.push(
+          this.createProposal(sessionId, 'multi_file_edit', 'pattern', {
+            title: `Multi-file change pattern in ${topDir} (${topFiles.length} files)`,
+            description: `Session modified ${topFiles.length} files in ${topDir}: ${topFiles.slice(0, 5).join(', ')}${topFiles.length > 5 ? '...' : ''}. This may indicate an architectural pattern.`,
+            confidence: Math.min(0.8, 0.4 + topFiles.length * 0.05),
+          }),
+        );
+      }
     }
 
-    // Rule 3: Long session (>30min)
+    // Rule 3: Long session (>30min) — neutral observation, not anti-pattern
     if (session.endedAt && session.startedAt) {
       const durationMs =
         new Date(session.endedAt).getTime() - new Date(session.startedAt).getTime();
@@ -615,23 +784,23 @@ export class BrainIntelligence {
       if (durationMin > EXTRACTION_LONG_SESSION_MINUTES) {
         rulesApplied.push('long_session');
         proposals.push(
-          this.createProposal(sessionId, 'long_session', 'anti-pattern', {
+          this.createProposal(sessionId, 'long_session', 'pattern', {
             title: `Long session (${Math.round(durationMin)} minutes)`,
-            description: `Session lasted ${Math.round(durationMin)} minutes. Consider breaking complex tasks into smaller steps or improving automation.`,
-            confidence: 0.5,
+            description: `Session lasted ${Math.round(durationMin)} minutes. Deep work session — review if this duration was productive or indicates a need for better tooling.`,
+            confidence: 0.3,
           }),
         );
       }
     }
 
-    // Rule 4: Plan completed
+    // Rule 4: Plan completed — moderate confidence to avoid auto-promoting generic entries
     if (session.planId && session.planOutcome === 'completed') {
       rulesApplied.push('plan_completed');
       proposals.push(
         this.createProposal(sessionId, 'plan_completed', 'workflow', {
           title: `Successful plan: ${session.planId}`,
           description: `Plan ${session.planId} completed successfully. This workflow can be reused for similar tasks.`,
-          confidence: 0.8,
+          confidence: 0.65,
         }),
       );
     }
@@ -887,6 +1056,18 @@ export class BrainIntelligence {
     // Step 3: Build domain profiles
     const domainProfiles = this.buildDomainProfiles(strengths);
 
+    // Step 4: Extract operator signals from domain expertise
+    try {
+      if (this.operatorProfile && strengths.length > 0) {
+        const signals = extractFromBrainStrengths(strengths);
+        if (signals.length > 0) {
+          this.operatorProfile.accumulateSignals(signals);
+        }
+      }
+    } catch {
+      // Signal extraction must never break intelligence pipeline
+    }
+
     return {
       strengthsComputed: strengths.length,
       globalPatterns,