@soleri/core 9.15.0 → 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/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/vault-connect.test.ts

@@ -127,7 +127,7 @@ describe('VaultManager — named connections', () => {
     const results = mgr.search('shared entry');
     const sameResults = results.filter((r) => r.entry.id === 'same-id');
     expect(sameResults.length).toBe(1);
-    // Score should reflect agent weight (1.0) not external (0.7)
+    // Dedup keeps only one result — agent tier wins, score is positive
     expect(sameResults[0].score).toBeGreaterThan(0);
   });
 

package/src/vault/vault-entries.ts

@@ -526,9 +526,11 @@ export function rowToSearchResult(row: Record<string, unknown>): SearchResult {
 
 /** Build FTS5 query from natural language: terms joined with OR for broad matching. */
 export function buildFtsQuery(query: string): string {
+  // Split on whitespace AND punctuation (hyphens, underscores, dots, slashes)
+  // so that "smoke-test-entry" and "snake_case" are treated as multi-term queries.
   const terms = query
     .toLowerCase()
-    .split(/\s+/)
+    .split(/[\s\-_./\\]+/)
     .filter((t) => t.length >= 2)
     .map((t) => t.replace(/[^a-z0-9]/g, ''))
     .filter(Boolean);

package/src/vault/vault.test.ts

@@ -98,13 +98,14 @@ describe('Vault', () => {
 
     it('should find entries matching query', () => {
       const results = vault.search('validation input');
-      expect(results.length).toBeGreaterThan(0);
+      expect(results).toHaveLength(1);
       expect(results[0].entry.id).toBe('search-1');
     });
 
     it('should return scores with results', () => {
       const results = vault.search('caching');
       expect(results[0].score).toBeGreaterThan(0);
+      expect(results[0].entry.id).toBe('search-2');
     });
 
     it('should filter by domain', () => {
@@ -121,6 +122,20 @@ describe('Vault', () => {
       const results = vault.search('xyznonexistent');
       expect(results).toEqual([]);
     });
+
+    it('should find entries by hyphenated query (smoke-test-entry style)', () => {
+      vault.seed([
+        makeEntry({
+          id: 'hyphen-test-1',
+          title: 'smoke-test-entry',
+          description: 'Hyphenated title entry for FTS regression.',
+          domain: 'testing',
+        }),
+      ]);
+      const results = vault.search('smoke-test-entry');
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].entry.id).toBe('hyphen-test-1');
+    });
   });
 
   describe('get', () => {
@@ -326,7 +341,7 @@ describe('Vault', () => {
         toolsUsed: [],
       });
       expect(memory.type).toBe('session');
-      expect(memory.createdAt).toBeGreaterThan(0);
+      expect(typeof memory.createdAt).toBe('number');
     });
 
     it('should capture preference memories', () => {
@@ -376,7 +391,7 @@ describe('Vault', () => {
 
     it('should find memories matching query', () => {
       const results = vault.searchMemories('parameterized queries');
-      expect(results.length).toBeGreaterThan(0);
+      expect(results).toHaveLength(1);
       expect(results[0].summary).toContain('parameterized');
     });
 
@@ -578,7 +593,7 @@ describe('Vault', () => {
 
       // Before archive: should appear in search
       const before = v.search('searchable');
-      expect(before.length).toBeGreaterThan(0);
+      expect(before).toHaveLength(1);
 
       v.archive({ olderThanDays: 90 });
 
@@ -643,7 +658,7 @@ describe('Vault', () => {
       v.restore('search-restore');
 
       const results = v.search('unique findable');
-      expect(results.length).toBeGreaterThan(0);
+      expect(results).toHaveLength(1);
       v.close();
     });
 
@@ -726,9 +741,9 @@ describe('Vault', () => {
         },
       ]);
       const stats = vault.contentHashStats();
-      expect(stats.total).toBeGreaterThanOrEqual(2);
-      expect(stats.hashed).toBe(stats.total);
-      expect(stats.uniqueHashes).toBe(stats.total);
+      expect(stats.total).toBe(2);
+      expect(stats.hashed).toBe(2);
+      expect(stats.uniqueHashes).toBe(2);
     });
 
     it('backfill hashes existing entries on re-initialize', () => {