@soleri/core 9.2.0 → 9.3.0

package/src/curator/quality-gate.test.ts

@@ -31,12 +31,20 @@ describe('evaluateQuality', () => {
   });
 
   it('returns ACCEPT for high-quality entry', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'ACCEPT',
-      overallScore: 85,
-      scores: { novelty: 80, actionability: 90, specificity: 85, relevance: 80, informationDensity: 90 },
-      reasoning: 'High quality entry with specific guidance.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 85,
+        scores: {
+          novelty: 80,
+          actionability: 90,
+          specificity: 85,
+          relevance: 80,
+          informationDensity: 90,
+        },
+        reasoning: 'High quality entry with specific guidance.',
+      }),
+    );
 
     const result = await evaluateQuality(makeEntry(), llm);
     expect(result.evaluated).toBe(true);
@@ -45,13 +53,21 @@ describe('evaluateQuality', () => {
   });
 
   it('returns REJECT for low-quality entry', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'REJECT',
-      overallScore: 30,
-      scores: { novelty: 10, actionability: 30, specificity: 40, relevance: 50, informationDensity: 20 },
-      reasoning: 'Too generic.',
-      rejectReasons: ['Low novelty', 'Not actionable'],
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'REJECT',
+        overallScore: 30,
+        scores: {
+          novelty: 10,
+          actionability: 30,
+          specificity: 40,
+          relevance: 50,
+          informationDensity: 20,
+        },
+        reasoning: 'Too generic.',
+        rejectReasons: ['Low novelty', 'Not actionable'],
+      }),
+    );
 
     const result = await evaluateQuality(makeEntry(), llm);
     expect(result.evaluated).toBe(true);
@@ -87,24 +103,40 @@ describe('evaluateQuality', () => {
   });
 
   it('normalizes non-REJECT verdict to ACCEPT', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'MAYBE',
-      overallScore: 60,
-      scores: { novelty: 60, actionability: 60, specificity: 60, relevance: 60, informationDensity: 60 },
-      reasoning: 'Borderline entry.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'MAYBE',
+        overallScore: 60,
+        scores: {
+          novelty: 60,
+          actionability: 60,
+          specificity: 60,
+          relevance: 60,
+          informationDensity: 60,
+        },
+        reasoning: 'Borderline entry.',
+      }),
+    );
 
     const result = await evaluateQuality(makeEntry(), llm);
     expect(result.verdict).toBe('ACCEPT');
   });
 
   it('includes optional entry fields in prompt', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'ACCEPT',
-      overallScore: 70,
-      scores: { novelty: 70, actionability: 70, specificity: 70, relevance: 70, informationDensity: 70 },
-      reasoning: 'OK.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 70,
+        scores: {
+          novelty: 70,
+          actionability: 70,
+          specificity: 70,
+          relevance: 70,
+          informationDensity: 70,
+        },
+        reasoning: 'OK.',
+      }),
+    );
 
     const entry = makeEntry();
     entry.why = 'Because security matters';
@@ -120,12 +152,20 @@ describe('evaluateQuality', () => {
   });
 
   it('uses low temperature for consistent scoring', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'ACCEPT',
-      overallScore: 70,
-      scores: { novelty: 70, actionability: 70, specificity: 70, relevance: 70, informationDensity: 70 },
-      reasoning: 'OK.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 70,
+        scores: {
+          novelty: 70,
+          actionability: 70,
+          specificity: 70,
+          relevance: 70,
+          informationDensity: 70,
+        },
+        reasoning: 'OK.',
+      }),
+    );
 
     await evaluateQuality(makeEntry(), llm);
 

package/src/curator/tag-manager.test.ts

@@ -16,8 +16,12 @@ function mockTagStore(): TagStore {
 
   return {
     getAlias: vi.fn((lower: string) => aliases.get(lower) ?? null),
-    insertCanonical: vi.fn((tag: string) => { canonicals.set(tag, null); }),
-    upsertAlias: vi.fn((alias: string, canonical: string) => { aliases.set(alias, canonical); }),
+    insertCanonical: vi.fn((tag: string) => {
+      canonicals.set(tag, null);
+    }),
+    upsertAlias: vi.fn((alias: string, canonical: string) => {
+      aliases.set(alias, canonical);
+    }),
     getCanonicalRows: vi.fn(() =>
       Array.from(canonicals.entries()).map(([tag, description]) => ({
         tag,
@@ -59,7 +63,11 @@ describe('tag-manager', () => {
 
     it('returns lowercased tag when no alias found', () => {
       const result = normalizeTag('MyCustomTag', store);
-      expect(result).toEqual({ original: 'MyCustomTag', normalized: 'mycustomtag', wasAliased: false });
+      expect(result).toEqual({
+        original: 'MyCustomTag',
+        normalized: 'mycustomtag',
+        wasAliased: false,
+      });
     });
 
     it('trims whitespace', () => {
@@ -92,7 +100,7 @@ describe('tag-manager', () => {
   describe('normalizeAndDedup', () => {
     it('deduplicates after normalization', () => {
       (store.getAlias as ReturnType<typeof vi.fn>)
-        .mockReturnValueOnce('styling')  // css -> styling
+        .mockReturnValueOnce('styling') // css -> styling
         .mockReturnValueOnce('styling'); // tailwind -> styling
       const { results, dedupedTags, changed } = normalizeAndDedup(['css', 'tailwind'], store);
       expect(results).toHaveLength(2);

package/src/domain-packs/knowledge-installer.test.ts

@@ -128,11 +128,7 @@ describe('installKnowledge', () => {
     const canonicalDir = join(tempDir, 'canonical');
     writeMdFiles(canonicalDir, { 'tagged.md': 'Tagged entry.' });
     const runtime = mockRuntime();
-    await installKnowledge(
-      mockPack({ knowledge: { canonical: 'canonical' } }),
-      runtime,
-      tempDir,
-    );
+    await installKnowledge(mockPack({ knowledge: { canonical: 'canonical' } }), runtime, tempDir);
     const addCall = (runtime.vault.add as unknown).mock.calls[0][0];
     expect(addCall.tags).toContain('pack:test-pack');
     expect(addCall.tags).toContain('tier:canonical');
@@ -144,11 +140,7 @@ describe('installKnowledge', () => {
     const curatedDir = join(tempDir, 'curated');
     writeMdFiles(curatedDir, { 'my-pattern.md': 'Content.' });
     const runtime = mockRuntime();
-    await installKnowledge(
-      mockPack({ knowledge: { curated: 'curated' } }),
-      runtime,
-      tempDir,
-    );
+    await installKnowledge(mockPack({ knowledge: { curated: 'curated' } }), runtime, tempDir);
     const addCall = (runtime.vault.add as unknown).mock.calls[0][0];
     expect(addCall.id).toBe('pack-test-pack-my-pattern');
   });

package/src/domain-packs/token-resolver.test.ts

@@ -75,9 +75,7 @@ describe('resolveToken', () => {
   });
 
   it('throws for unknown token', () => {
-    expect(() => resolveToken('unknown-token', emptyProject())).toThrow(
-      /Cannot resolve token/,
-    );
+    expect(() => resolveToken('unknown-token', emptyProject())).toThrow(/Cannot resolve token/);
   });
 
   it('throws for unknown color scale', () => {

package/src/domain-packs/types.test.ts

@@ -53,7 +53,9 @@ describe('validateDomainPack', () => {
   });
 
   it('accepts pack with rules string', () => {
-    const result = validateDomainPack(minimalPack({ rules: '## Token Rules\nUse semantic tokens.' }));
+    const result = validateDomainPack(
+      minimalPack({ rules: '## Token Rules\nUse semantic tokens.' }),
+    );
     expect(result.success).toBe(true);
   });
 
@@ -122,7 +124,19 @@ describe('SEMANTIC_FACADE_NAMES', () => {
   });
 
   it('contains all core engine facades', () => {
-    const expected = ['vault', 'plan', 'brain', 'memory', 'admin', 'curator', 'loop', 'orchestrate', 'control', 'cognee', 'governance'];
+    const expected = [
+      'vault',
+      'plan',
+      'brain',
+      'memory',
+      'admin',
+      'curator',
+      'loop',
+      'orchestrate',
+      'control',
+      'cognee',
+      'governance',
+    ];
     for (const name of expected) {
       expect(SEMANTIC_FACADE_NAMES).toContain(name);
     }

package/src/enforcement/registry.test.ts

@@ -74,10 +74,7 @@ describe('EnforcementRegistry', () => {
 
   describe('getEnabledRules', () => {
     it('excludes disabled rules', () => {
-      registry.addRules([
-        makeRule({ id: 'active' }),
-        makeRule({ id: 'disabled', enabled: false }),
-      ]);
+      registry.addRules([makeRule({ id: 'active' }), makeRule({ id: 'disabled', enabled: false })]);
       const enabled = registry.getEnabledRules();
       expect(enabled).toHaveLength(1);
       expect(enabled[0].id).toBe('active');
@@ -91,10 +88,7 @@ describe('EnforcementRegistry', () => {
 
   describe('getConfig', () => {
     it('returns config with only enabled rules', () => {
-      registry.addRules([
-        makeRule({ id: 'on' }),
-        makeRule({ id: 'off', enabled: false }),
-      ]);
+      registry.addRules([makeRule({ id: 'on' }), makeRule({ id: 'off', enabled: false })]);
       const config = registry.getConfig();
       expect(config.rules).toHaveLength(1);
       expect(config.rules[0].id).toBe('on');

package/src/engine/bin/soleri-engine.ts

@@ -169,7 +169,9 @@ async function main(): Promise<void> {
     const syncResult = syncSkillsToClaudeCode([skillsDir], config.name as string);
     const total = syncResult.installed.length + syncResult.updated.length;
     if (total > 0) {
-      console.error(`${tag} Skills synced: ${syncResult.installed.length} new, ${syncResult.updated.length} updated`);
+      console.error(
+        `${tag} Skills synced: ${syncResult.installed.length} new, ${syncResult.updated.length} updated`,
+      );
     }
   }
 

package/src/engine/module-manifest.test.ts

@@ -29,10 +29,11 @@ describe('ENGINE_MODULE_MANIFEST', () => {
     expect(suffixes).toContain('agency');
     expect(suffixes).toContain('chat');
     expect(suffixes).toContain('operator');
+    expect(suffixes).toContain('intake');
   });
 
-  it('has exactly 16 modules', () => {
-    expect(ENGINE_MODULE_MANIFEST).toHaveLength(16);
+  it('has exactly 20 modules', () => {
+    expect(ENGINE_MODULE_MANIFEST).toHaveLength(20);
   });
 
   it('has no duplicate suffixes', () => {
@@ -118,7 +119,7 @@ describe('manifest order stability', () => {
     expect(ENGINE_MODULE_MANIFEST[0].suffix).toBe('vault');
   });
 
-  it('review is the last module', () => {
-    expect(ENGINE_MODULE_MANIFEST[ENGINE_MODULE_MANIFEST.length - 1].suffix).toBe('review');
+  it('tier is the last module', () => {
+    expect(ENGINE_MODULE_MANIFEST[ENGINE_MODULE_MANIFEST.length - 1].suffix).toBe('tier');
   });
 });

package/src/engine/module-manifest.ts

@@ -25,7 +25,7 @@ export interface ModuleManifestEntry {
 export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
   {
     suffix: 'vault',
-    description: 'Knowledge management — search, CRUD, import/export, intake, sharing, linking.',
+    description: 'Knowledge management — search, CRUD, capture, sharing scope.',
     keyOps: ['search_intelligent', 'capture_knowledge', 'capture_quick'],
   },
   {
@@ -104,6 +104,26 @@ export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
     description: 'Knowledge review workflow.',
     keyOps: ['vault_submit_review', 'vault_approve', 'vault_reject'],
   },
+  {
+    suffix: 'intake',
+    description: 'Content ingestion — books, URLs, text, batch import.',
+    keyOps: ['intake_ingest_book', 'ingest_url', 'ingest_text', 'ingest_batch'],
+  },
+  {
+    suffix: 'links',
+    description: 'Entry linking — create, traverse, suggest, orphan detection.',
+    keyOps: ['link_entries', 'traverse', 'suggest_links', 'get_orphans'],
+  },
+  {
+    suffix: 'branching',
+    description: 'Vault branching — create, list, merge, delete branches.',
+    keyOps: ['vault_branch', 'vault_branch_list', 'vault_merge_branch'],
+  },
+  {
+    suffix: 'tier',
+    description: 'Multi-vault tiers — connect, disconnect, search across sources.',
+    keyOps: ['vault_connect_source', 'vault_search_all', 'vault_list_sources'],
+  },
 ];
 
 /** Core facade ops (always present, not in ENGINE_MODULES) */

package/src/engine/register-engine.test.ts

@@ -97,7 +97,12 @@ describe('registerEngine — core ops', () => {
   it('registers core facade when coreOps provided', () => {
     const server = makeServer();
     const coreOps: OpDefinition[] = [
-      { name: 'health', description: 'Health check', auth: 'read', handler: async () => ({ ok: true }) },
+      {
+        name: 'health',
+        description: 'Health check',
+        auth: 'read',
+        handler: async () => ({ ok: true }),
+      },
     ];
     const result = registerEngine(server, runtime, { agentId: 'core', coreOps });
     expect(result.tools).toContain('core_core');

package/src/engine/register-engine.ts

@@ -39,6 +39,10 @@ import { createOperatorFacadeOps } from '../runtime/facades/operator-facade.js';
 import { createArchiveFacadeOps } from '../runtime/facades/archive-facade.js';
 import { createSyncFacadeOps } from '../runtime/facades/sync-facade.js';
 import { createReviewFacadeOps } from '../runtime/facades/review-facade.js';
+import { createIntakeFacadeOps } from '../runtime/facades/intake-facade.js';
+import { createLinksFacadeOps } from '../runtime/facades/links-facade.js';
+import { createBranchingFacadeOps } from '../runtime/facades/branching-facade.js';
+import { createTierFacadeOps } from '../runtime/facades/tier-facade.js';
 import { createDomainFacade } from '../runtime/domain-ops.js';
 
 // ─── Types ────────────────────────────────────────────────────────────
@@ -88,7 +92,7 @@ interface ModuleDef {
 export const ENGINE_MODULES: ModuleDef[] = [
   {
     suffix: 'vault',
-    description: 'Knowledge management — search, CRUD, import/export, intake, sharing, linking.',
+    description: 'Knowledge management — search, CRUD, capture, sharing scope.',
     createOps: createVaultFacadeOps,
   },
   {
@@ -123,8 +127,7 @@ export const ENGINE_MODULES: ModuleDef[] = [
   },
   {
     suffix: 'orchestrate',
-    description:
-      'Execution orchestration — session start, playbooks, plan/execute/complete.',
+    description: 'Execution orchestration — session start, playbooks, plan/execute/complete.',
     createOps: createOrchestrateFacadeOps,
   },
   {
@@ -167,6 +170,26 @@ export const ENGINE_MODULES: ModuleDef[] = [
     description: 'Knowledge review workflow.',
     createOps: createReviewFacadeOps,
   },
+  {
+    suffix: 'intake',
+    description: 'Content ingestion — books, URLs, text, batch import.',
+    createOps: createIntakeFacadeOps,
+  },
+  {
+    suffix: 'links',
+    description: 'Entry linking — create, traverse, suggest, orphan detection.',
+    createOps: createLinksFacadeOps,
+  },
+  {
+    suffix: 'branching',
+    description: 'Vault branching — create, list, merge, delete branches.',
+    createOps: createBranchingFacadeOps,
+  },
+  {
+    suffix: 'tier',
+    description: 'Multi-vault tiers — connect, disconnect, search across sources.',
+    createOps: createTierFacadeOps,
+  },
 ];
 
 // ─── Core Registration ────────────────────────────────────────────────

package/src/errors/classify.test.ts

@@ -95,7 +95,9 @@ describe('classifyError', () => {
 
   describe('message pattern classification', () => {
     it('should classify "overloaded" as LLM_OVERLOAD', () => {
-      expect(classifyError(new Error('server is overloaded')).code).toBe(SoleriErrorCode.LLM_OVERLOAD);
+      expect(classifyError(new Error('server is overloaded')).code).toBe(
+        SoleriErrorCode.LLM_OVERLOAD,
+      );
     });
 
     it('should classify "model busy" as LLM_OVERLOAD', () => {
@@ -123,7 +125,9 @@ describe('classifyError', () => {
     });
 
     it('should classify "not found" as RESOURCE_NOT_FOUND', () => {
-      expect(classifyError(new Error('resource not found')).code).toBe(SoleriErrorCode.RESOURCE_NOT_FOUND);
+      expect(classifyError(new Error('resource not found')).code).toBe(
+        SoleriErrorCode.RESOURCE_NOT_FOUND,
+      );
     });
 
     it('should classify "rate limit" as RATE_LIMIT', () => {

package/src/errors/retry.test.ts

@@ -118,10 +118,7 @@ describe('retryWithPreset', () => {
 
   it('should call onRetry callback on each retry', async () => {
     const onRetry = vi.fn();
-    const fn = vi
-      .fn()
-      .mockRejectedValueOnce(new Error('network fail'))
-      .mockResolvedValue('ok');
+    const fn = vi.fn().mockRejectedValueOnce(new Error('network fail')).mockResolvedValue('ok');
 
     const resultPromise = retryWithPreset(fn, 'fast', { onRetry });
     await vi.advanceTimersByTimeAsync(20_000);