@soleri/core 2.12.0 → 8.0.0

package/src/__tests__/token-resolver.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolveToken,
+  listProjectTokens,
+  buildReverseIndex,
+} from '../domain-packs/token-resolver.js';
+import type { PackProjectContext } from '../domain-packs/pack-runtime.js';
+
+const mockProject: PackProjectContext = {
+  id: 'test-project',
+  name: 'Test Project',
+  path: '/test',
+  colors: {
+    primary: {
+      base: '#3B82F6',
+      scale: { '50': '#EFF6FF', '100': '#DBEAFE', '500': '#3B82F6', '900': '#1E3A5F' },
+    },
+    neutral: {
+      base: '#6B7280',
+      scale: { '50': '#F9FAFB', '100': '#F3F4F6', '500': '#6B7280', '900': '#111827' },
+    },
+  },
+  semanticTokens: {
+    'text-inverse': '#FFFFFF',
+    'bg-surface': '#F9FAFB',
+  },
+};
+
+describe('resolveToken', () => {
+  it('should pass through hex values', () => {
+    expect(resolveToken('#FF0000', mockProject)).toBe('#FF0000');
+  });
+
+  it('should resolve named colors', () => {
+    expect(resolveToken('white', mockProject)).toBe('#FFFFFF');
+    expect(resolveToken('black', mockProject)).toBe('#000000');
+  });
+
+  it('should resolve semantic tokens', () => {
+    expect(resolveToken('text-inverse', mockProject)).toBe('#FFFFFF');
+    expect(resolveToken('bg-surface', mockProject)).toBe('#F9FAFB');
+  });
+
+  it('should resolve SCALE[SHADE] format', () => {
+    expect(resolveToken('PRIMARY[500]', mockProject)).toBe('#3B82F6');
+    expect(resolveToken('neutral[900]', mockProject)).toBe('#111827');
+  });
+
+  it('should resolve Tailwind-style tokens', () => {
+    expect(resolveToken('bg-primary-500', mockProject)).toBe('#3B82F6');
+    expect(resolveToken('text-neutral-900', mockProject)).toBe('#111827');
+  });
+
+  it('should throw for unknown tokens', () => {
+    expect(() => resolveToken('unknown-token', mockProject)).toThrow('Cannot resolve');
+  });
+
+  it('should throw for unknown scales', () => {
+    expect(() => resolveToken('ACCENT[500]', mockProject)).toThrow('Unknown color scale');
+  });
+});
+
+describe('listProjectTokens', () => {
+  it('should list all scale and semantic tokens', () => {
+    const tokens = listProjectTokens(mockProject);
+    expect(tokens.length).toBeGreaterThan(0);
+    expect(tokens.some((t) => t.token === 'primary-500')).toBe(true);
+    expect(tokens.some((t) => t.token === 'text-inverse')).toBe(true);
+    expect(tokens.some((t) => t.scale === 'semantic')).toBe(true);
+  });
+});
+
+describe('buildReverseIndex', () => {
+  it('should map hex to token name', () => {
+    const index = buildReverseIndex(mockProject);
+    expect(index.get('#3B82F6')).toBe('primary-500');
+    expect(index.get('#FFFFFF')).toBe('text-inverse');
+  });
+});

package/src/agency/agency-manager.ts

@@ -15,6 +15,7 @@ import { watch, readFileSync, existsSync } from 'node:fs';
 import { join, extname } from 'node:path';
 import type { FSWatcher } from 'node:fs';
 import type { Vault } from '../vault/vault.js';
+import { DEFAULT_SUGGESTION_RULES } from './default-rules.js';
 import type {
   AgencyConfig,
   AgencyStatus,
@@ -24,6 +25,11 @@ import type {
   WarningDetector,
   SurfacedPattern,
   ClarificationQuestion,
+  SuggestionRule,
+  SuggestionContext,
+  ProactiveSuggestion,
+  RichClarificationQuestion,
+  Notification,
 } from './types.js';
 
 // ─── Defaults ──────────────────────────────────────────────────────
@@ -57,6 +63,14 @@ export class AgencyManager {
   private cooldownMap = new Map<string, number>();
   private debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
+  // Proactive intelligence (#211)
+  private suggestionRules: SuggestionRule[] = [];
+  private recentFiles: FileChange[] = [];
+  private suppressedWarningIds = new Set<string>();
+  private dismissedPatterns = new Map<string, number>(); // entryId → dismissedAt timestamp
+  private dismissalTtlMs = 24 * 60 * 60 * 1000; // 24 hours
+  private notificationQueue: Notification[] = [];
+
   constructor(vault: Vault, config?: AgencyConfig) {
     this.vault = vault;
     this.config = {
@@ -68,6 +82,11 @@ export class AgencyManager {
       minPatternConfidence: config?.minPatternConfidence ?? DEFAULT_MIN_CONFIDENCE,
       cooldownMs: config?.cooldownMs ?? DEFAULT_COOLDOWN_MS,
     };
+
+    // Register built-in suggestion rules
+    for (const rule of DEFAULT_SUGGESTION_RULES) {
+      this.suggestionRules.push(rule);
+    }
   }
 
   // ─── Lifecycle ──────────────────────────────────────────────────
@@ -84,15 +103,7 @@ export class AgencyManager {
   }
 
   getStatus(): AgencyStatus {
-    return {
-      enabled: this.config.enabled,
-      watching: this.watchers.length > 0,
-      watchPaths: this.config.watchPaths,
-      detectorCount: this.detectors.length,
-      pendingWarnings: this.pendingWarnings.length,
-      surfacedPatterns: this.surfacedPatterns.length,
-      fileChangesProcessed: this.changesProcessed,
-    };
+    return this.getFullStatus();
   }
 
   updateConfig(config: Partial<AgencyConfig>): void {
@@ -323,4 +334,201 @@ export class AgencyManager {
     const ext = extname(filePath);
     return this.config.extensions.includes(ext);
   }
+
+  // ─── Proactive Suggestions (#211) ──────────────────────────────────
+
+  registerSuggestionRule(rule: SuggestionRule): void {
+    this.suggestionRules.push(rule);
+  }
+
+  /**
+   * Evaluate all suggestion rules and return triggered suggestions.
+   */
+  generateSuggestions(): ProactiveSuggestion[] {
+    const context: SuggestionContext = {
+      recentFiles: this.recentFiles.slice(-20),
+      pendingWarnings: this.pendingWarnings,
+      surfacedPatterns: this.surfacedPatterns,
+      fileChangesProcessed: this.changesProcessed,
+    };
+
+    const suggestions: ProactiveSuggestion[] = [];
+    for (const rule of this.suggestionRules) {
+      try {
+        if (rule.condition(context)) {
+          suggestions.push(rule.generate(context));
+        }
+      } catch {
+        // Rule failure is non-critical
+      }
+    }
+
+    // Create notifications for suggestions
+    for (const s of suggestions) {
+      this.pushNotification('suggestion', s.title, s.description, s.priority);
+    }
+
+    return suggestions.sort((a, b) => {
+      const prio = { high: 0, medium: 1, low: 2 };
+      return prio[a.priority] - prio[b.priority];
+    });
+  }
+
+  // ─── Rich Clarification (#211) ─────────────────────────────────────
+
+  generateRichClarification(prompt: string): RichClarificationQuestion[] {
+    const questions: RichClarificationQuestion[] = [];
+
+    // Ambiguous scope detection
+    const scopeWords = ['everything', 'all', 'the whole', 'entire'];
+    if (scopeWords.some((w) => prompt.toLowerCase().includes(w))) {
+      questions.push({
+        question: 'That sounds like a broad scope. Can you narrow it down?',
+        reason: 'Broad requests often lead to unfocused work',
+        urgency: 'recommended',
+        options: [
+          { label: 'Just the current file', description: 'Focus on what I have open' },
+          { label: 'This module/directory', description: 'Scope to the current package' },
+          {
+            label: 'The full project',
+            description: 'I really mean everything',
+            implications: 'This may take significantly longer',
+          },
+        ],
+      });
+    }
+
+    // Missing context detection
+    const vagueVerbs = ['fix', 'improve', 'update', 'change'];
+    const hasVagueVerb = vagueVerbs.some((v) => prompt.toLowerCase().startsWith(v));
+    const isShort = prompt.split(/\s+/).length < 5;
+    if (hasVagueVerb && isShort) {
+      questions.push({
+        question: 'Could you describe the specific problem or desired outcome?',
+        reason: `"${prompt}" is ambiguous — different interpretations lead to different solutions`,
+        urgency: 'blocking',
+        options: [
+          { label: "There's an error/bug", description: 'Something is broken' },
+          { label: 'It works but needs improvement', description: 'Refactoring or enhancement' },
+          { label: 'Add new behavior', description: 'Feature addition' },
+        ],
+      });
+    }
+
+    // Destructive operation detection
+    const destructiveWords = ['delete', 'remove', 'drop', 'reset', 'wipe', 'purge'];
+    if (destructiveWords.some((w) => prompt.toLowerCase().includes(w))) {
+      questions.push({
+        question: 'This sounds like a destructive operation. Are you sure?',
+        reason: 'Destructive actions are hard to undo',
+        urgency: 'blocking',
+        options: [
+          {
+            label: 'Yes, proceed',
+            description: 'I understand the consequences',
+            recommended: false,
+          },
+          {
+            label: 'Let me reconsider',
+            description: 'Show me what would be affected first',
+            recommended: true,
+          },
+        ],
+      });
+    }
+
+    return questions;
+  }
+
+  // ─── Warning Suppression (#211) ────────────────────────────────────
+
+  suppressWarning(warningId: string): void {
+    this.suppressedWarningIds.add(warningId);
+    this.pendingWarnings = this.pendingWarnings.filter((w) => w.id !== warningId);
+  }
+
+  unsuppressWarning(warningId: string): void {
+    this.suppressedWarningIds.delete(warningId);
+  }
+
+  getSuppressedWarnings(): string[] {
+    return [...this.suppressedWarningIds];
+  }
+
+  /**
+   * Override getPendingWarnings to filter out suppressed.
+   */
+  getFilteredWarnings(): Warning[] {
+    return this.pendingWarnings.filter((w) => !this.suppressedWarningIds.has(w.id));
+  }
+
+  // ─── Pattern Dismissal (#211) ──────────────────────────────────────
+
+  dismissPattern(entryId: string): void {
+    this.dismissedPatterns.set(entryId, Date.now());
+    this.surfacedPatterns = this.surfacedPatterns.filter((p) => p.entryId !== entryId);
+  }
+
+  isDismissed(entryId: string): boolean {
+    const dismissedAt = this.dismissedPatterns.get(entryId);
+    if (!dismissedAt) return false;
+    if (Date.now() - dismissedAt > this.dismissalTtlMs) {
+      this.dismissedPatterns.delete(entryId);
+      return false;
+    }
+    return true;
+  }
+
+  getActiveSurfacedPatterns(): SurfacedPattern[] {
+    return this.surfacedPatterns.filter((p) => !this.isDismissed(p.entryId));
+  }
+
+  // ─── Notification Queue (#211) ─────────────────────────────────────
+
+  pushNotification(
+    type: Notification['type'],
+    title: string,
+    message: string,
+    priority: Notification['priority'] = 'medium',
+  ): void {
+    this.notificationQueue.push({
+      id: `notif-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      type,
+      title,
+      message,
+      priority,
+      createdAt: Date.now(),
+    });
+  }
+
+  drainNotifications(): Notification[] {
+    const notifications = [...this.notificationQueue];
+    this.notificationQueue = [];
+    return notifications.sort((a, b) => {
+      const prio = { high: 0, medium: 1, low: 2 };
+      return prio[a.priority] - prio[b.priority];
+    });
+  }
+
+  getPendingNotificationCount(): number {
+    return this.notificationQueue.length;
+  }
+
+  // ─── Extended Status (#211) ────────────────────────────────────────
+
+  getFullStatus(): AgencyStatus {
+    return {
+      enabled: this.config.enabled,
+      watching: this.watchers.length > 0,
+      watchPaths: this.config.watchPaths,
+      detectorCount: this.detectors.length,
+      pendingWarnings: this.getFilteredWarnings().length,
+      surfacedPatterns: this.getActiveSurfacedPatterns().length,
+      fileChangesProcessed: this.changesProcessed,
+      suggestionRuleCount: this.suggestionRules.length,
+      suppressedWarnings: this.suppressedWarningIds.size,
+      dismissedPatterns: this.dismissedPatterns.size,
+      pendingNotifications: this.notificationQueue.length,
+    };
+  }
 }

package/src/agency/default-rules.ts

@@ -0,0 +1,83 @@
+/**
+ * Default suggestion rules — 6 built-in rules that work for any agent.
+ * Registered on agent startup so agency_suggestions works out of the box.
+ */
+
+import type { SuggestionRule } from './types.js';
+
+export const DEFAULT_SUGGESTION_RULES: SuggestionRule[] = [
+  {
+    name: 'many-warnings',
+    description: 'Fires when 5+ warnings are pending',
+    condition: (ctx) => ctx.pendingWarnings.length >= 5,
+    generate: (ctx) => ({
+      rule: 'many-warnings',
+      title: `${ctx.pendingWarnings.length} warnings pending`,
+      description: `You have ${ctx.pendingWarnings.length} unresolved warnings — consider running a scan or addressing the critical ones.`,
+      priority: 'high',
+      action: 'Run agency_warnings to review',
+    }),
+  },
+  {
+    name: 'stale-patterns',
+    description: 'Fires when surfaced patterns suggest stale knowledge',
+    condition: (ctx) => ctx.surfacedPatterns.length === 0 && ctx.fileChangesProcessed > 20,
+    generate: () => ({
+      rule: 'stale-patterns',
+      title: 'Knowledge base maintenance recommended',
+      description:
+        'No patterns surfaced despite significant file activity — vault may need grooming or new knowledge.',
+      priority: 'medium',
+      action: 'Run curator_health_audit',
+    }),
+  },
+  {
+    name: 'high-activity-no-capture',
+    description: 'Fires when many files changed but no patterns captured',
+    condition: (ctx) => ctx.fileChangesProcessed > 50 && ctx.surfacedPatterns.length === 0,
+    generate: (ctx) => ({
+      rule: 'high-activity-no-capture',
+      title: 'Long session without knowledge capture',
+      description: `${ctx.fileChangesProcessed} file changes processed — consider capturing what you've learned.`,
+      priority: 'medium',
+      action: 'Run smart_capture or radar_analyze',
+    }),
+  },
+  {
+    name: 'critical-warnings',
+    description: 'Fires when critical-severity warnings exist',
+    condition: (ctx) => ctx.pendingWarnings.some((w) => w.severity === 'critical'),
+    generate: (ctx) => {
+      const critical = ctx.pendingWarnings.filter((w) => w.severity === 'critical');
+      return {
+        rule: 'critical-warnings',
+        title: `${critical.length} critical warning(s) need attention`,
+        description: critical.map((w) => w.message).join('; '),
+        priority: 'high',
+      };
+    },
+  },
+  {
+    name: 'pattern-surfaced',
+    description: 'Fires when relevant vault patterns were found for changed files',
+    condition: (ctx) => ctx.surfacedPatterns.length > 0,
+    generate: (ctx) => ({
+      rule: 'pattern-surfaced',
+      title: `${ctx.surfacedPatterns.length} relevant pattern(s) found`,
+      description: ctx.surfacedPatterns.map((p) => `${p.title} (${p.domain})`).join(', '),
+      priority: 'low',
+    }),
+  },
+  {
+    name: 'first-session',
+    description: 'Fires on first use when no file changes have been processed',
+    condition: (ctx) => ctx.fileChangesProcessed === 0 && ctx.pendingWarnings.length === 0,
+    generate: () => ({
+      rule: 'first-session',
+      title: 'Agency mode ready',
+      description:
+        'File watching and proactive suggestions are enabled. Start editing files to see patterns and warnings.',
+      priority: 'low',
+    }),
+  },
+];

package/src/agency/types.ts

@@ -85,4 +85,65 @@ export interface AgencyStatus {
   pendingWarnings: number;
   surfacedPatterns: number;
   fileChangesProcessed: number;
+  suggestionRuleCount: number;
+  suppressedWarnings: number;
+  dismissedPatterns: number;
+  pendingNotifications: number;
+}
+
+// ─── Proactive Suggestions (#211) ────────────────────────────────────
+
+export interface SuggestionRule {
+  /** Unique name for this rule. */
+  name: string;
+  /** Human description of what this rule detects. */
+  description: string;
+  /** Condition: returns true if this rule should fire. */
+  condition(context: SuggestionContext): boolean;
+  /** Generate a suggestion when condition is true. */
+  generate(context: SuggestionContext): ProactiveSuggestion;
+}
+
+export interface SuggestionContext {
+  recentFiles: FileChange[];
+  pendingWarnings: Warning[];
+  surfacedPatterns: SurfacedPattern[];
+  fileChangesProcessed: number;
+}
+
+export interface ProactiveSuggestion {
+  rule: string;
+  title: string;
+  description: string;
+  priority: 'high' | 'medium' | 'low';
+  action?: string;
+}
+
+// ─── Rich Clarification (#211) ───────────────────────────────────────
+
+export type ClarificationUrgency = 'blocking' | 'recommended' | 'optional';
+
+export interface ClarificationOption {
+  label: string;
+  description?: string;
+  implications?: string;
+  recommended?: boolean;
+}
+
+export interface RichClarificationQuestion {
+  question: string;
+  reason: string;
+  urgency: ClarificationUrgency;
+  options?: ClarificationOption[];
+}
+
+// ─── Notifications (#211) ────────────────────────────────────────────
+
+export interface Notification {
+  id: string;
+  type: 'suggestion' | 'warning' | 'pattern';
+  title: string;
+  message: string;
+  priority: 'high' | 'medium' | 'low';
+  createdAt: number;
 }

package/src/brain/brain.ts

@@ -1,5 +1,6 @@
 import type { Vault } from '../vault/vault.js';
 import type { SearchResult } from '../vault/vault.js';
+import type { VaultManager } from '../vault/vault-manager.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 import { computeContentHash } from '../vault/content-hash.js';
 import {
@@ -14,6 +15,7 @@ import type {
   ScoringWeights,
   ScoreBreakdown,
   RankedResult,
+  ScanResult,
   SearchOptions,
   CaptureResult,
   BrainStats,
@@ -59,12 +61,14 @@ const RECENCY_HALF_LIFE_DAYS = 365;
 
 export class Brain {
   private vault: Vault;
+  private vaultManager: VaultManager | undefined;
   private cognee: CogneeClient | undefined;
   private vocabulary: Map<string, number> = new Map();
   private weights: ScoringWeights = { ...DEFAULT_WEIGHTS };
 
-  constructor(vault: Vault, cognee?: CogneeClient) {
+  constructor(vault: Vault, cognee?: CogneeClient, vaultManager?: VaultManager) {
     this.vault = vault;
+    this.vaultManager = vaultManager;
     this.cognee = cognee;
     this.rebuildVocabulary();
     this.recomputeWeights();
@@ -72,12 +76,31 @@ export class Brain {
 
   async intelligentSearch(query: string, options?: SearchOptions): Promise<RankedResult[]> {
     const limit = options?.limit ?? 10;
-    const rawResults = this.vault.search(query, {
-      domain: options?.domain,
-      type: options?.type,
-      severity: options?.severity,
-      limit: Math.max(limit * 3, 30),
-    });
+    const fetchLimit = Math.max(limit * 3, 30);
+
+    // Use VaultManager when available to search across all connected sources
+    // (agent tier + shared vault + dynamically connected external vaults).
+    // Falls back to single vault search when no manager is present.
+    let rawResults: SearchResult[];
+    if (this.vaultManager) {
+      rawResults = this.vaultManager.search(query, fetchLimit);
+      // Apply domain/type/severity filters that VaultManager.search() doesn't support
+      if (options?.domain || options?.type || options?.severity) {
+        rawResults = rawResults.filter((r) => {
+          if (options.domain && r.entry.domain !== options.domain) return false;
+          if (options.type && r.entry.type !== options.type) return false;
+          if (options.severity && r.entry.severity !== options.severity) return false;
+          return true;
+        });
+      }
+    } else {
+      rawResults = this.vault.search(query, {
+        domain: options?.domain,
+        type: options?.type,
+        severity: options?.severity,
+        limit: fetchLimit,
+      });
+    }
 
     // Cognee vector search (parallel, with timeout fallback)
     let cogneeScoreMap: Map<string, number> = new Map();
@@ -212,6 +235,49 @@ export class Brain {
     return ranked.slice(0, limit);
   }
 
+  /**
+   * Two-pass retrieval — Pass 1: Scan.
+   * Returns lightweight results (title, score, snippet) without full entry bodies.
+   * Use `loadEntries()` for Pass 2 to fetch full content for selected entries.
+   */
+  async scanSearch(query: string, options?: Omit<SearchOptions, 'mode'>): Promise<ScanResult[]> {
+    const fullResults = await this.intelligentSearch(query, { ...options, mode: 'full' });
+    return fullResults.map((r) => ({
+      id: r.entry.id,
+      title: r.entry.title,
+      score: r.score,
+      type: r.entry.type,
+      domain: r.entry.domain,
+      severity: r.entry.severity,
+      tags: r.entry.tags,
+      snippet: r.entry.description.slice(0, 120) + (r.entry.description.length > 120 ? '...' : ''),
+      tokenEstimate: this.estimateTokens(r.entry),
+    }));
+  }
+
+  /**
+   * Two-pass retrieval — Pass 2: Load.
+   * Returns full entries for specific IDs (from a previous scan).
+   */
+  loadEntries(ids: string[]): IntelligenceEntry[] {
+    const results: IntelligenceEntry[] = [];
+    for (const id of ids) {
+      const entry = this.vault.get(id);
+      if (entry) results.push(entry);
+    }
+    return results;
+  }
+
+  /** Rough token estimate for an entry (chars / 4). */
+  private estimateTokens(entry: IntelligenceEntry): number {
+    let chars = entry.title.length + entry.description.length;
+    if (entry.context) chars += entry.context.length;
+    if (entry.example) chars += entry.example.length;
+    if (entry.counterExample) chars += entry.counterExample.length;
+    if (entry.why) chars += entry.why.length;
+    return Math.ceil(chars / 4);
+  }
+
   enrichAndCapture(
     entry: Partial<IntelligenceEntry> & {
       id: string;
@@ -426,7 +492,43 @@ export class Brain {
   }
 
   rebuildVocabulary(): void {
-    const entries = this.vault.list({ limit: 100000 });
+    // Collect entries from all connected sources when VaultManager is available
+    let entries: IntelligenceEntry[];
+    if (this.vaultManager) {
+      const seen = new Set<string>();
+      entries = [];
+      // Gather entries from all tier vaults and connected sources via manager
+      for (const tierInfo of this.vaultManager.listTiers()) {
+        if (!tierInfo.connected) continue;
+        try {
+          const tierVault = this.vaultManager.getTier(tierInfo.tier);
+          for (const e of tierVault.list({ limit: 100000 })) {
+            if (!seen.has(e.id)) {
+              seen.add(e.id);
+              entries.push(e);
+            }
+          }
+        } catch {
+          /* tier not connected */
+        }
+      }
+      for (const { name } of this.vaultManager.listConnected()) {
+        const cv = this.vaultManager.getConnected(name);
+        if (!cv) continue;
+        try {
+          for (const e of cv.vault.list({ limit: 100000 })) {
+            if (!seen.has(e.id)) {
+              seen.add(e.id);
+              entries.push(e);
+            }
+          }
+        } catch {
+          /* source not accessible */
+        }
+      }
+    } else {
+      entries = this.vault.list({ limit: 100000 });
+    }
     const docCount = entries.length;
     if (docCount === 0) {
       this.vocabulary.clear();

package/src/brain/intelligence.ts

@@ -497,12 +497,31 @@ export class BrainIntelligence {
     limit?: number;
   }): PatternStrength[] {
     const limit = context.limit ?? 5;
-    const strengths = this.getStrengths({
+
+    // Try domain-filtered first, fall back to all domains if too few results
+    let strengths = this.getStrengths({
       domain: context.domain,
-      minStrength: 30,
+      minStrength: 20, // lowered from 30 — small corpus needs lower threshold
       limit: limit * 3,
     });
 
+    // If domain-filtered returns too few, try without domain filter
+    // This handles cases where domain was stored as 'unknown' due to
+    // vault.get() returning null during computeStrengths
+    if (strengths.length < limit && context.domain) {
+      const allStrengths = this.getStrengths({
+        minStrength: 20,
+        limit: limit * 5,
+      });
+      // Include domain-matching AND entries where domain lookup failed
+      const additional = allStrengths.filter(
+        (s) =>
+          !strengths.some((existing) => existing.pattern === s.pattern) &&
+          (s.domain === context.domain || s.domain === 'unknown'),
+      );
+      strengths = [...strengths, ...additional];
+    }
+
     // If task context provided, boost patterns with matching terms
     if (context.task) {
       const taskTerms = new Set(context.task.toLowerCase().split(/\W+/).filter(Boolean));