@soleri/core 9.14.4 → 9.16.7

package/src/vault/__tests__/vault-characterization.test.ts

@@ -51,14 +51,6 @@ describe('Vault Characterization Tests', () => {
   });
 
   describe('constructor', () => {
-    it('creates an in-memory vault', () => {
-      const v = new Vault(':memory:');
-      expect(v).toBeInstanceOf(Vault);
-      v.close();
-    });
-    it('stamps FORMAT_VERSION', () => {
-      expect(Vault.FORMAT_VERSION).toBe(1);
-    });
     it('createWithSQLite factory', () => {
       const v = Vault.createWithSQLite(':memory:');
       expect(v).toBeInstanceOf(Vault);
@@ -83,26 +75,11 @@ describe('Vault Characterization Tests', () => {
   });
 
   describe('seed', () => {
-    it('inserts entries', () => {
-      expect(vault.seed([makeEntry({ id: 'seed-1' })])).toBe(1);
-    });
     it('upserts on conflict', () => {
       vault.seed([makeEntry({ id: 'u1', title: 'Old' })]);
       vault.seed([makeEntry({ id: 'u1', title: 'New' })]);
       expect(vault.get('u1')?.title).toBe('New');
     });
-    it('handles multiple', () => {
-      expect(
-        vault.seed([makeEntry({ id: 'a1' }), makeEntry({ id: 'a2' }), makeEntry({ id: 'a3' })]),
-      ).toBe(3);
-    });
-  });
-
-  describe('add', () => {
-    it('delegates to seed', () => {
-      vault.add(makeEntry({ id: 'add-1' }));
-      expect(vault.get('add-1')).toBeTruthy();
-    });
   });
 
   describe('get', () => {
@@ -172,10 +149,6 @@ describe('Vault Characterization Tests', () => {
   });
 
   describe('list', () => {
-    it('returns entries', () => {
-      vault.seed([makeEntry({ id: 'l1' }), makeEntry({ id: 'l2' })]);
-      expect(vault.list().length).toBe(2);
-    });
     it('filters by domain', () => {
       vault.seed([
         makeEntry({ id: 'ld1', domain: 'react' }),
@@ -245,13 +218,6 @@ describe('Vault Characterization Tests', () => {
       ]);
     });
   });
-  describe('getRecent', () => {
-    it('returns entries', () => {
-      vault.seed([makeEntry({ id: 'r1' })]);
-      vault.seed([makeEntry({ id: 'r2' })]);
-      expect(vault.getRecent(5).length).toBe(2);
-    });
-  });
 
   describe('setTemporal', () => {
     it('sets temporal fields', () => {
@@ -319,30 +285,7 @@ describe('Vault Characterization Tests', () => {
       expect(vault.findByContentHash('x')).toBeNull();
     });
   });
-  describe('contentHashStats', () => {
-    it('zeros for empty', () => {
-      const s = vault.contentHashStats();
-      expect(s.total).toBe(0);
-    });
-    it('counts', () => {
-      vault.seed([
-        makeEntry({ id: 'c1', title: 'First' }),
-        makeEntry({ id: 'c2', title: 'Second' }),
-      ]);
-      const s = vault.contentHashStats();
-      expect(s.total).toBe(2);
-      expect(s.uniqueHashes).toBe(2);
-    });
-  });
 
-  describe('exportAll', () => {
-    it('exports all', () => {
-      vault.seed([makeEntry({ id: 'e1' }), makeEntry({ id: 'e2' })]);
-      const r = vault.exportAll();
-      expect(r.count).toBe(2);
-      expect(typeof r.exportedAt).toBe('number');
-    });
-  });
   describe('getAgeReport', () => {
     it('empty report', () => {
       const r = vault.getAgeReport();
@@ -389,12 +332,6 @@ describe('Vault Characterization Tests', () => {
     });
   });
 
-  describe('optimize', () => {
-    it('returns status', () => {
-      const r = vault.optimize();
-      expect(typeof r.vacuumed).toBe('boolean');
-    });
-  });
   describe('rebuildFtsIndex', () => {
     it('does not throw', () => {
       expect(() => vault.rebuildFtsIndex()).not.toThrow();
@@ -402,10 +339,6 @@ describe('Vault Characterization Tests', () => {
   });
 
   describe('registerProject', () => {
-    it('registers new', () => {
-      const p = vault.registerProject('/t', 'test');
-      expect(p.sessionCount).toBe(1);
-    });
     it('increments on re-register', () => {
       vault.registerProject('/t');
       expect(vault.registerProject('/t').sessionCount).toBe(2);
@@ -424,21 +357,7 @@ describe('Vault Characterization Tests', () => {
       expect(vault.getProject('/t')!.name).toBe('T');
     });
   });
-  describe('listProjects', () => {
-    it('lists all', () => {
-      vault.registerProject('/a');
-      vault.registerProject('/b');
-      expect(vault.listProjects().length).toBe(2);
-    });
-  });
 
-  describe('captureMemory', () => {
-    it('creates with id', () => {
-      const m = vault.captureMemory(makeMemoryInput());
-      expect(m.id).toMatch(/^mem-/);
-      expect(m.archivedAt).toBeNull();
-    });
-  });
   describe('getMemory', () => {
     it('returns null', () => {
       expect(vault.getMemory('x')).toBeNull();
@@ -489,9 +408,6 @@ describe('Vault Characterization Tests', () => {
   });
 
   describe('memoryStats', () => {
-    it('zeros for empty', () => {
-      expect(vault.memoryStats().total).toBe(0);
-    });
     it('counts', () => {
       vault.captureMemory(makeMemoryInput({ projectPath: '/a', type: 'session' }));
       vault.captureMemory(makeMemoryInput({ projectPath: '/a', type: 'lesson' }));
@@ -502,20 +418,6 @@ describe('Vault Characterization Tests', () => {
     });
   });
 
-  describe('memoryStatsDetailed', () => {
-    it('includes extended fields', () => {
-      vault.captureMemory(makeMemoryInput());
-      const s = vault.memoryStatsDetailed();
-      expect(typeof s.oldest).toBe('number');
-      expect(s.archivedCount).toBe(0);
-    });
-  });
-  describe('exportMemories', () => {
-    it('exports', () => {
-      vault.captureMemory(makeMemoryInput());
-      expect(vault.exportMemories().length).toBe(1);
-    });
-  });
   describe('importMemories', () => {
     it('imports and deduplicates', () => {
       vault.captureMemory(makeMemoryInput());
@@ -560,16 +462,6 @@ describe('Vault Characterization Tests', () => {
     });
   });
 
-  describe('getProvider', () => {
-    it('returns provider', () => {
-      expect(vault.getProvider().backend).toBe('sqlite');
-    });
-  });
-  describe('getDb', () => {
-    it('returns db', () => {
-      expect(vault.getDb()).toBeTruthy();
-    });
-  });
   describe('close', () => {
     it('does not throw', () => {
       const v = new Vault(':memory:');

package/src/vault/default-canonical-tags.ts

@@ -0,0 +1,64 @@
+/**
+ * Default canonical tag taxonomy for Soleri agents.
+ *
+ * These tags represent the most common knowledge domains. When a vault is
+ * configured with tagConstraintMode 'suggest' or 'enforce', incoming tags
+ * are mapped to the nearest entry in this list via edit-distance matching.
+ *
+ * To use these defaults in your agent runtime config:
+ *   import { DEFAULT_CANONICAL_TAGS } from '@soleri/core';
+ *   // ...
+ *   canonicalTags: DEFAULT_CANONICAL_TAGS,
+ *   tagConstraintMode: 'suggest',
+ */
+export const DEFAULT_CANONICAL_TAGS: string[] = [
+  'architecture',
+  'typescript',
+  'react',
+  'testing',
+  'workflow',
+  'design-tokens',
+  'accessibility',
+  'performance',
+  'security',
+  'planning',
+  'soleri',
+  'vault',
+  'mcp',
+  'claude-code',
+  'ai',
+  'learning',
+  'gamification',
+  'education',
+  'adhd',
+  'routing',
+  'orchestration',
+  'skills',
+  'automation',
+  'git',
+  'database',
+  'api',
+  'authentication',
+  'subagent',
+  'design-system',
+  'component',
+  'frontend',
+  'backend',
+  'tooling',
+  'monorepo',
+  'refactoring',
+  'debugging',
+  'deployment',
+  'configuration',
+  'documentation',
+  'pattern',
+  'anti-pattern',
+  'principle',
+  'decision',
+  'migration',
+  'plugin',
+  'hook',
+  'schema',
+  'pipeline',
+  'ingestion',
+];

package/src/vault/linking.test.ts

@@ -355,7 +355,6 @@ describe('LinkManager', () => {
     const result = mgr.backfillLinks();
     expect(result.processed).toBe(0);
     expect(result.linksCreated).toBe(0);
-    expect(result.durationMs).toBeGreaterThanOrEqual(0);
   });
 
   it('dry run populates preview array', () => {
@@ -385,7 +384,6 @@ describe('LinkManager', () => {
     if (result.processed > 0 && result.preview) {
       expect(Array.isArray(result.preview)).toBe(true);
     }
-    expect(result.durationMs).toBeGreaterThanOrEqual(0);
   });
 
   it('calls onProgress callback', () => {

package/src/vault/playbook.test.ts

@@ -95,7 +95,10 @@ describe('validatePlaybook', () => {
     const steps = [makeStep({ title: '', description: '' }, 1)];
     const result = validatePlaybook(makePlaybook({ title: '', steps }));
     expect(result.valid).toBe(false);
-    expect(result.errors.length).toBeGreaterThanOrEqual(3);
+    expect(result.errors).toHaveLength(3);
+    expect(result.errors).toContain('Playbook title must not be empty');
+    expect(result.errors).toContain('Step 1 title must not be empty');
+    expect(result.errors).toContain('Step 1 description must not be empty');
   });
 });
 

package/src/vault/scope-detector.test.ts

@@ -165,11 +165,13 @@ describe('detectScope', () => {
     const result = detectScope(
       makeInput({ description: 'Use focus ring for keyboard navigation' }),
     );
+    expect(result.signals.length).toBeGreaterThan(0);
     for (const signal of result.signals) {
       expect(signal).toHaveProperty('tier');
       expect(signal).toHaveProperty('source');
       expect(signal).toHaveProperty('indicator');
       expect(signal).toHaveProperty('weight');
+      // Weight must be in (0, 1] range
       expect(signal.weight).toBeGreaterThan(0);
       expect(signal.weight).toBeLessThanOrEqual(1);
     }
@@ -179,7 +181,7 @@ describe('detectScope', () => {
     const result = detectScope(
       makeInput({ description: 'Accessibility best practice for a11y compliance' }),
     );
-    expect(result.reason.length).toBeGreaterThan(0);
+    expect(result.reason).toMatch(/accessibility|a11y/i);
     expect(result.reason).not.toContain('defaulting');
   });
 });

package/src/vault/scope-detector.ts

@@ -49,7 +49,27 @@ const TEAM_CONTENT_PATTERNS: Array<{ pattern: RegExp; weight: number; desc: stri
   { pattern: /error\s+handling|error\s+boundary/i, weight: 0.6, desc: 'error handling' },
   { pattern: /touch\s+target|tap\s+target|fitts/i, weight: 0.8, desc: 'UX touch targets' },
   { pattern: /focus\s+(ring|state|indicator)/i, weight: 0.8, desc: 'focus states' },
-  { pattern: /best\s+practice|anti.?pattern/i, weight: 0.65, desc: 'best practice' },
+  // Reduced weight: "best practice" alone is too weak to push to team tier
+  { pattern: /best\s+practice|anti.?pattern/i, weight: 0.4, desc: 'best practice' },
+];
+
+/**
+ * Project-specific negative signals — agent/tool names and framework-specific patterns
+ * that indicate the entry is project-scoped, not universally applicable.
+ */
+const PROJECT_SPECIFIC_PATTERNS: Array<{ pattern: RegExp; weight: number; desc: string }> = [
+  { pattern: /\bsoleri\b/i, weight: 0.9, desc: 'Soleri project reference' },
+  { pattern: /\bernesto\b/i, weight: 0.9, desc: 'Ernesto agent reference' },
+  { pattern: /\bsalvador\b/i, weight: 0.9, desc: 'Salvador agent reference' },
+  {
+    pattern: /\bskill\s+(file|system|pack|registry|sync)/i,
+    weight: 0.7,
+    desc: 'skill system specific',
+  },
+  { pattern: /vault\s+(entry|search|op|facade)/i, weight: 0.65, desc: 'vault system specific' },
+  { pattern: /domain\s+pack|hook\s+pack/i, weight: 0.7, desc: 'Soleri pack system' },
+  { pattern: /plan\s+(grade|facade|lifecycle)/i, weight: 0.65, desc: 'Soleri planning system' },
+  { pattern: /soleri\s+(agent|cli|core|forge)/i, weight: 0.95, desc: 'Soleri package reference' },
 ];
 
 const PROJECT_CONTENT_PATTERNS: Array<{ pattern: RegExp; weight: number; desc: string }> = [
@@ -128,6 +148,11 @@ function analyzeContent(text: string): ScopeSignal[] {
       signals.push({ tier: 'project', source: 'content', indicator: desc, weight });
     }
   }
+  for (const { pattern, weight, desc } of PROJECT_SPECIFIC_PATTERNS) {
+    if (pattern.test(text)) {
+      signals.push({ tier: 'project', source: 'content', indicator: desc, weight });
+    }
+  }
   for (const { pattern, weight, desc } of AGENT_CONTENT_PATTERNS) {
     if (pattern.test(text)) {
       signals.push({ tier: 'agent', source: 'content', indicator: desc, weight });
@@ -165,7 +190,11 @@ function analyzeTags(tags: string[]): ScopeSignal[] {
   return signals;
 }
 
-function computeConfidence(scores: Record<ScopeTier, number>, winner: ScopeTier): ConfidenceLevel {
+function computeConfidence(
+  scores: Record<ScopeTier, number>,
+  winner: ScopeTier,
+  signals: ScopeSignal[],
+): ConfidenceLevel {
   const winScore = scores[winner];
   const others = Object.entries(scores)
     .filter(([t]) => t !== winner)
@@ -173,7 +202,16 @@ function computeConfidence(scores: Record<ScopeTier, number>, winner: ScopeTier)
   const runnerUp = Math.max(...others, 0);
 
   if (winScore === 0) return 'LOW';
-  if (runnerUp === 0 && winScore >= 0.5) return 'HIGH';
+  if (runnerUp === 0 && winScore >= 0.5) {
+    // Cap team tier at MEDIUM when only generic/methodology signals drove the win
+    if (winner === 'team') {
+      const genericOnly = signals
+        .filter((s) => s.tier === 'team')
+        .every((s) => s.indicator === 'best practice' || s.source === 'category');
+      if (genericOnly) return 'MEDIUM';
+    }
+    return 'HIGH';
+  }
   const ratio = winScore / (winScore + runnerUp);
   if (ratio >= 0.7 && winScore >= 1.0) return 'HIGH';
   if (ratio >= 0.55) return 'MEDIUM';
@@ -205,7 +243,7 @@ export function detectScope(input: ScopeInput): ScopeDetectionResult {
     }
   }
 
-  const confidence = computeConfidence(scores, winner);
+  const confidence = computeConfidence(scores, winner, signals);
   const topSignals = signals
     .filter((s) => s.tier === winner)
     .sort((a, b) => b.weight - a.weight)

package/src/vault/tag-normalizer.test.ts

@@ -0,0 +1,214 @@
+import { describe, it, expect } from 'vitest';
+import {
+  computeEditDistance,
+  normalizeTag,
+  normalizeTags,
+  isMetadataTag,
+} from './tag-normalizer.js';
+
+// ─── computeEditDistance ────────────────────────────────────────────────────
+
+describe('computeEditDistance', () => {
+  it('returns 0 for identical strings', () => {
+    expect(computeEditDistance('workflow', 'workflow')).toBe(0);
+  });
+
+  it('returns length of b for empty a', () => {
+    expect(computeEditDistance('', 'abc')).toBe(3);
+  });
+
+  it('returns length of a for empty b', () => {
+    expect(computeEditDistance('abc', '')).toBe(3);
+  });
+
+  it('single insertion: workflow → workflows', () => {
+    expect(computeEditDistance('workflow', 'workflows')).toBe(1);
+  });
+
+  it('single deletion: testing → testin', () => {
+    expect(computeEditDistance('testing', 'testin')).toBe(1);
+  });
+
+  it('single substitution: arch → arcs', () => {
+    expect(computeEditDistance('arch', 'arcs')).toBe(1);
+  });
+
+  it("distance 1: architcture → architecture (single insertion - missing 'e')", () => {
+    expect(computeEditDistance('architcture', 'architecture')).toBe(1);
+  });
+
+  it('distance 2: archtecrure → architecture (two edits)', () => {
+    expect(computeEditDistance('archtecrure', 'architecture')).toBe(2);
+  });
+
+  it('large distance: typescript → javascript', () => {
+    expect(computeEditDistance('typescript', 'javascript')).toBeGreaterThan(3);
+  });
+
+  it('is symmetric', () => {
+    expect(computeEditDistance('foo', 'bar')).toBe(computeEditDistance('bar', 'foo'));
+  });
+});
+
+// ─── isMetadataTag ──────────────────────────────────────────────────────────
+
+describe('isMetadataTag', () => {
+  it('returns true when tag matches a prefix', () => {
+    expect(isMetadataTag('source:article', ['source:'])).toBe(true);
+  });
+
+  it('returns true for exact prefix match', () => {
+    expect(isMetadataTag('source:ingested', ['source:'])).toBe(true);
+  });
+
+  it('returns false when no prefix matches', () => {
+    expect(isMetadataTag('typescript', ['source:'])).toBe(false);
+  });
+
+  it('returns false with empty prefix list', () => {
+    expect(isMetadataTag('source:article', [])).toBe(false);
+  });
+
+  it('supports multiple prefixes', () => {
+    expect(isMetadataTag('meta:foo', ['source:', 'meta:'])).toBe(true);
+  });
+});
+
+// ─── normalizeTag ───────────────────────────────────────────────────────────
+
+const CANONICAL = ['architecture', 'typescript', 'workflow', 'testing', 'performance'];
+
+describe('normalizeTag — mode: off', () => {
+  it('returns tag as-is regardless of canonical list', () => {
+    expect(normalizeTag('workflows', CANONICAL, 'off')).toBe('workflows');
+  });
+
+  it('passes through noise words in off mode', () => {
+    expect(normalizeTag('new', CANONICAL, 'off')).toBe('new');
+  });
+});
+
+describe('normalizeTag — noise stripping', () => {
+  it('drops version strings (v1.2)', () => {
+    expect(normalizeTag('v1.2', CANONICAL, 'suggest')).toBeNull();
+  });
+
+  it('drops version strings (v10)', () => {
+    expect(normalizeTag('v10', CANONICAL, 'suggest')).toBeNull();
+  });
+
+  it('drops generic noise word: new', () => {
+    expect(normalizeTag('new', CANONICAL, 'suggest')).toBeNull();
+  });
+
+  it('drops generic noise word: via', () => {
+    expect(normalizeTag('via', CANONICAL, 'suggest')).toBeNull();
+  });
+
+  it('drops generic noise word: raw', () => {
+    expect(normalizeTag('raw', CANONICAL, 'enforce')).toBeNull();
+  });
+});
+
+describe('normalizeTag — mode: suggest', () => {
+  it('returns canonical for exact match', () => {
+    expect(normalizeTag('typescript', CANONICAL, 'suggest')).toBe('typescript');
+  });
+
+  it('maps within edit-distance 2 to canonical', () => {
+    // 'workflows' is distance 1 from 'workflow'
+    expect(normalizeTag('workflows', CANONICAL, 'suggest')).toBe('workflow');
+  });
+
+  it('lowercases tag before matching', () => {
+    expect(normalizeTag('TypeScript', CANONICAL, 'suggest')).toBe('typescript');
+  });
+
+  it('passes through unknown tag with no close canonical (suggest passthrough)', () => {
+    const result = normalizeTag('gamification', CANONICAL, 'suggest');
+    // No match within distance 2 — passthrough
+    expect(result).toBe('gamification');
+  });
+
+  it('returns null for noise even in suggest mode', () => {
+    expect(normalizeTag('one', CANONICAL, 'suggest')).toBeNull();
+  });
+});
+
+describe('normalizeTag — mode: enforce', () => {
+  it('returns canonical for exact match', () => {
+    expect(normalizeTag('testing', CANONICAL, 'enforce')).toBe('testing');
+  });
+
+  it('maps within edit-distance 3 to canonical', () => {
+    // 'archtecrure' is 2 away from 'architecture'
+    expect(normalizeTag('archtecrure', CANONICAL, 'enforce')).toBe('architecture');
+  });
+
+  it('returns null for tag with no match within distance 3', () => {
+    // 'gamification' is far from all CANONICAL entries
+    expect(normalizeTag('gamification', CANONICAL, 'enforce')).toBeNull();
+  });
+
+  it('returns null for noise words', () => {
+    expect(normalizeTag('full', CANONICAL, 'enforce')).toBeNull();
+  });
+});
+
+describe('normalizeTag — empty canonical list', () => {
+  it('suggest mode: passes through non-noise tags', () => {
+    expect(normalizeTag('react', [], 'suggest')).toBe('react');
+  });
+
+  it('enforce mode: drops all tags (no canonical to match)', () => {
+    expect(normalizeTag('react', [], 'enforce')).toBeNull();
+  });
+});
+
+// ─── normalizeTags ──────────────────────────────────────────────────────────
+
+describe('normalizeTags', () => {
+  it('deduplicates tags that map to the same canonical', () => {
+    // Both 'workflows' and 'workflow' normalize to 'workflow'
+    const result = normalizeTags(['workflows', 'workflow'], CANONICAL, 'suggest');
+    expect(result).toEqual(['workflow']);
+  });
+
+  it('preserves metadata tags unchanged', () => {
+    const result = normalizeTags(['source:article', 'typescript'], CANONICAL, 'enforce', [
+      'source:',
+    ]);
+    expect(result).toContain('source:article');
+    expect(result).toContain('typescript');
+  });
+
+  it('metadata tags bypass canonical normalization in enforce mode', () => {
+    // 'source:mytype' does not match any canonical — but it should be kept
+    const result = normalizeTags(['source:mytype'], CANONICAL, 'enforce', ['source:']);
+    expect(result).toEqual(['source:mytype']);
+  });
+
+  it('returns empty array when all tags are noise', () => {
+    const result = normalizeTags(['new', 'via', 'raw', 'v1.2'], CANONICAL, 'suggest');
+    expect(result).toEqual([]);
+  });
+
+  it('in off mode, returns tags unchanged', () => {
+    const input = ['new', 'workflows', 'v1.2'];
+    const result = normalizeTags(input, CANONICAL, 'off');
+    expect(result).toEqual(input);
+  });
+
+  it('batch normalizes a mixed tag list', () => {
+    const result = normalizeTags(
+      ['TypeScript', 'workflows', 'new', 'source:article'],
+      CANONICAL,
+      'suggest',
+      ['source:'],
+    );
+    expect(result).toContain('typescript');
+    expect(result).toContain('workflow');
+    expect(result).toContain('source:article');
+    expect(result).not.toContain('new');
+  });
+});