@soleri/core 9.15.0 → 9.16.7

package/src/agency/agency-manager.test.ts

@@ -219,7 +219,7 @@ describe('AgencyManager', () => {
     it('returns patterns from vault for .ts files', () => {
       seedVaultWithPattern(vault);
       const p = manager.surfacePatterns('/project/src/module.ts');
-      expect(p.length).toBeGreaterThan(0);
+      expect(p.length).toBe(1);
       expect(p[0].trigger).toBe('/project/src/module.ts');
       expect(p[0].entryId).toBe('ts-pattern-1');
     });
@@ -238,14 +238,14 @@ describe('AgencyManager', () => {
     it('different files are independent of each other cooldown', () => {
       seedVaultWithPattern(vault);
       manager.surfacePatterns('/project/src/a.ts');
-      expect(manager.surfacePatterns('/project/src/b.ts').length).toBeGreaterThan(0);
+      expect(manager.surfacePatterns('/project/src/b.ts').length).toBe(1);
     });
 
     it('accumulates in getSurfacedPatterns', () => {
       seedVaultWithPattern(vault);
       manager.surfacePatterns('/project/a.ts');
       manager.surfacePatterns('/project/b.tsx');
-      expect(manager.getSurfacedPatterns().length).toBeGreaterThanOrEqual(2);
+      expect(manager.getSurfacedPatterns().length).toBe(2);
     });
 
     it('clearSurfacedPatterns resets accumulator', () => {
@@ -536,7 +536,7 @@ describe('AgencyManager', () => {
     it('creates notifications for each suggestion', () => {
       expect(manager.getPendingNotificationCount()).toBe(0);
       manager.generateSuggestions(); // first-session fires
-      expect(manager.getPendingNotificationCount()).toBeGreaterThan(0);
+      expect(manager.getPendingNotificationCount()).toBe(1);
     });
   });
 

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

@@ -47,19 +47,6 @@ function findRule(name: string) {
 }
 
 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', () => {

package/src/brain/brain-intelligence.test.ts

@@ -38,11 +38,6 @@ describe('BrainIntelligence', () => {
     expect(stats.domainProfiles).toBe(0);
   });
 
-  it('should be accessible from runtime', () => {
-    expect(runtime.brainIntelligence).toBeDefined();
-    expect(typeof runtime.brainIntelligence.getStats).toBe('function');
-  });
-
   // ─── Session Lifecycle ──────────────────────────────────────────
 
   it('should start a session', () => {

package/src/brain/second-brain-features.test.ts

@@ -33,7 +33,7 @@ import type { IntelligenceEntry } from '../intelligence/types.js';
 
 let vault: Vault;
 let brain: Brain;
-let brainIntelligence: BrainIntelligence;
+let _brainIntelligence: BrainIntelligence;
 let planner: Planner;
 let curator: Curator;
 let intentRouter: IntentRouter;
@@ -99,7 +99,7 @@ beforeAll(() => {
   vault = new Vault(':memory:');
   vault.seed(SEED);
   brain = new Brain(vault);
-  brainIntelligence = new BrainIntelligence(vault, brain);
+  _brainIntelligence = new BrainIntelligence(vault, brain);
   planner = new Planner(join(tempDir, 'plans.json'));
   curator = new Curator(vault);
   intentRouter = new IntentRouter(vault);
@@ -160,18 +160,6 @@ describe('Two-pass vault retrieval (#205)', () => {
 // ─── 2. Session Briefing ─────────────────────────────────────────────
 
 describe('Session briefing (#202)', () => {
-  // Session briefing is an op — tested via the module imports directly
-  it('brainIntelligence.listSessions returns sessions', () => {
-    const sessions = brainIntelligence.listSessions({ limit: 5 });
-    // May be empty in a fresh vault, but shouldn't throw
-    expect(Array.isArray(sessions)).toBe(true);
-  });
-
-  it('planner.list returns plans array', () => {
-    const plans = planner.list();
-    expect(Array.isArray(plans)).toBe(true);
-  });
-
   it('vault.getRecent returns recent entries', () => {
     const recent = vault.getRecent(5);
     expect(recent.length).toBeGreaterThan(0);

package/src/capabilities/chain-mapping.test.ts

@@ -6,10 +6,6 @@ describe('chainToCapability', () => {
     expect(chainToCapability('vault-search')).toBe('vault.search');
   });
 
-  it('maps vault-search-antipatterns to vault.search', () => {
-    expect(chainToCapability('vault-search-antipatterns')).toBe('vault.search');
-  });
-
   it('maps memory-search to memory.search', () => {
     expect(chainToCapability('memory-search')).toBe('memory.search');
   });
@@ -39,9 +35,8 @@ describe('chainToCapability', () => {
     expect(chainToCapability('get-stack-guidelines')).toBe('stack.guidelines');
   });
 
-  it('maps architecture and cognee chains', () => {
+  it('maps architecture chains', () => {
     expect(chainToCapability('architecture-search')).toBe('architecture.search');
-    expect(chainToCapability('cognee-design-search')).toBe('cognee.search');
   });
 
   it('maps planning chains', () => {

package/src/capabilities/chain-mapping.ts

@@ -22,7 +22,7 @@
  *   deliver.flow.yaml  — validate-component, validate-tokens,
  *                         design-rules-check, test-coverage-check,
  *                         performance-audit, delivery-checklist
- *   design.flow.yaml   — vault-search, memory-search, cognee-design-search,
+ *   design.flow.yaml   — vault-search, memory-search,
  *                         recommend-design-system, recommend-style,
  *                         recommend-palette, recommend-typography,
  *                         get-stack-guidelines, brain-recommend
@@ -30,7 +30,7 @@
  *                         brain-recommend, validate-component, validate-tokens
  *   explore.flow.yaml  — vault-search, memory-search, brain-strengths,
  *                         brain-recommend, playbook-search
- *   fix.flow.yaml      — vault-search-antipatterns, memory-search,
+ *   fix.flow.yaml      — vault-search, memory-search,
  *                         error-pattern-search, brain-recommend,
  *                         validate-component, validate-tokens
  *   plan.flow.yaml     — vault-search, memory-search, brain-recommend,
@@ -42,7 +42,6 @@
 const CHAIN_TO_CAPABILITY: Record<string, string> = {
   // Vault & Knowledge
   'vault-search': 'vault.search',
-  'vault-search-antipatterns': 'vault.search',
   'memory-search': 'memory.search',
   'playbook-search': 'vault.playbook',
 
@@ -67,11 +66,14 @@ const CHAIN_TO_CAPABILITY: Record<string, string> = {
 
   // Architecture
   'architecture-search': 'architecture.search',
-  'cognee-design-search': 'cognee.search',
 
   // Planning
   'plan-create': 'plan.create',
 
+  // Capture & Synthesis
+  'capture-baseline-state': 'vault.capture',
+  'vault-synthesize': 'vault.synthesize',
+
   // Review & Quality
   'review-report': 'review.report',
   'accessibility-audit': 'a11y.audit',

package/src/capabilities/registry.test.ts

@@ -237,7 +237,7 @@ describe('CapabilityRegistry', () => {
     it('classifies blocking capabilities correctly', () => {
       const result = registry.validateFlow({
         steps: [{ needs: ['vault.search', 'auth.validate'] }],
-        onMissingCapability: { blocking: ['auth.validate'] },
+        'on-missing-capability': { blocking: ['auth.validate'] },
       });
 
       expect(result.valid).toBe(false);

package/src/capabilities/registry.ts

@@ -33,6 +33,12 @@ export interface FlowForValidation {
     needs?: string[];
     chains?: string[];
   }>;
+  /** Kebab-case (YAML / flow file format). */
+  'on-missing-capability'?: {
+    default?: string;
+    blocking?: string[];
+  };
+  /** CamelCase alias for programmatic callers. */
   onMissingCapability?: {
     default?: string;
     blocking?: string[];
@@ -236,8 +242,9 @@ export class CapabilityRegistry {
       }
     }
 
-    // Classify missing capabilities by impact
-    const blockingSet = new Set(flow.onMissingCapability?.blocking ?? []);
+    // Classify missing capabilities by impact (accept both kebab and camelCase keys)
+    const missingCapConfig = flow['on-missing-capability'] ?? flow.onMissingCapability;
+    const blockingSet = new Set(missingCapConfig?.blocking ?? []);
 
     const degraded = missing.map((capability) => ({
       capability,

package/src/chat/agent-loop.test.ts

@@ -286,7 +286,7 @@ describe('runAgentLoop', () => {
           onToolUse: (name) => toolUses.push(name),
           onToolResult: (name, result, ms) => {
             toolResults.push(`${name}:${result.output}`);
-            expect(ms).toBeGreaterThanOrEqual(0);
+            expect(typeof ms).toBe('number');
           },
         },
       );

package/src/chat/chat-enhanced.test.ts

@@ -14,7 +14,6 @@ import {
   cleanupTempFiles,
   sanitizeForPersistence,
   MAX_FILE_SIZE,
-  TEXT_EXTENSIONS,
 } from './file-handler.js';
 import { NotificationEngine } from './notifications.js';
 import type { FileInfo, MultimodalContent } from './file-handler.js';
@@ -231,13 +230,6 @@ describe('File Handler', () => {
     });
   });
 
-  test('TEXT_EXTENSIONS includes common types', () => {
-    expect(TEXT_EXTENSIONS.has('.ts')).toBe(true);
-    expect(TEXT_EXTENSIONS.has('.py')).toBe(true);
-    expect(TEXT_EXTENSIONS.has('.json')).toBe(true);
-    expect(TEXT_EXTENSIONS.has('.md')).toBe(true);
-  });
-
   test('MAX_FILE_SIZE is 20MB', () => {
     expect(MAX_FILE_SIZE).toBe(20 * 1024 * 1024);
   });

package/src/claudemd/compose.test.ts

@@ -35,11 +35,6 @@ const facades: FacadeConfig[] = [
 ];
 
 describe('compose — constants', () => {
-  it('FORMAT_VERSION is a positive integer', () => {
-    expect(FORMAT_VERSION).toBeGreaterThan(0);
-    expect(Number.isInteger(FORMAT_VERSION)).toBe(true);
-  });
-
   it('markers contain version', () => {
     expect(OPEN_MARKER).toContain(`v${FORMAT_VERSION}`);
   });

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

@@ -398,7 +398,6 @@ describe('ContextEngine', () => {
 
     it('processing time is a non-negative number', async () => {
       const result = await engine.analyze('any prompt');
-      expect(result.processingTimeMs).toBeGreaterThanOrEqual(0);
       expect(typeof result.processingTimeMs).toBe('number');
     });
 

package/src/context/context-engine.ts

@@ -48,7 +48,7 @@ const ENTITY_PATTERNS: Array<{ type: EntityType; pattern: RegExp; confidence: nu
   {
     type: 'technology',
     pattern:
-      /\b(?:react|vue|svelte|angular|typescript|javascript|node\.?js|python|rust|go|docker|kubernetes|postgres|sqlite|redis|tailwind|css|html|graphql|rest|grpc)\b/gi,
+      /\b(?:react|vue|svelte|angular|typescript|javascript|node\.?js|python|rust|go|docker|kubernetes|postgres|sqlite|redis|tailwind|css|html|graphql|rest|grpc|vitest|jest|mocha|playwright|cypress)\b/gi,
     confidence: 0.85,
   },
   // Patterns: kebab-case compound terms that look like patterns

package/src/control/intent-router.test.ts

@@ -57,7 +57,7 @@ describe('IntentRouter', () => {
       expect(result.mode).toBe('FIX-MODE');
       expect(result.method).toBe('keyword');
       expect(result.confidence).toBeGreaterThan(0);
-      expect(result.matchedKeywords.length).toBeGreaterThan(0);
+      expect(result.matchedKeywords.length).toBe(2);
     });
 
     it('classifies "build a new component" as BUILD intent', () => {
@@ -117,7 +117,7 @@ describe('IntentRouter', () => {
       // "fix bug broken error" has 4 FIX keywords vs anything else
       const result = router.routeIntent('fix bug broken error');
       expect(result.intent).toBe('fix');
-      expect(result.matchedKeywords.length).toBeGreaterThanOrEqual(4);
+      expect(result.matchedKeywords.length).toBe(4);
     });
 
     it('confidence is capped at 1.0', () => {

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

@@ -41,10 +41,6 @@ describe('tag-manager', () => {
   });
 
   describe('DEFAULT_TAG_ALIASES', () => {
-    it('exports expected alias count', () => {
-      expect(DEFAULT_TAG_ALIASES.length).toBe(13);
-    });
-
     it('includes common aliases', () => {
       const aliasMap = new Map(DEFAULT_TAG_ALIASES);
       expect(aliasMap.get('a11y')).toBe('accessibility');

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

@@ -118,11 +118,6 @@ describe('validateDomainPack', () => {
 });
 
 describe('SEMANTIC_FACADE_NAMES', () => {
-  it('is a readonly array (TypeScript enforced)', () => {
-    expect(Array.isArray(SEMANTIC_FACADE_NAMES)).toBe(true);
-    expect(SEMANTIC_FACADE_NAMES.length).toBeGreaterThan(0);
-  });
-
   it('contains all core engine facades', () => {
     const expected = [
       'vault',

package/src/dream/dream.test.ts

@@ -134,13 +134,6 @@ describe('dream ops', () => {
     vault.close();
   });
 
-  it('creates 3 ops with correct names', () => {
-    expect(ops).toHaveLength(3);
-    expect(ops.map((o) => o.name).sort()).toEqual(
-      ['dream_check_gate', 'dream_run', 'dream_status'].sort(),
-    );
-  });
-
   it('dream_status returns status', async () => {
     const result = (await findOp('dream_status').handler({})) as Record<string, unknown>;
     expect(result).toHaveProperty('sessionsSinceLastDream');

package/src/enforcement/registry.test.ts

@@ -136,7 +136,7 @@ describe('EnforcementRegistry', () => {
       const result = registry.translate('claude-code');
       expect(result.host).toBe('claude-code');
       // Only r1 should be translated (r2 is disabled)
-      expect(result.files.length).toBeGreaterThan(0);
+      expect(result.files.length).toBe(1);
     });
   });
 
@@ -250,7 +250,7 @@ describe('ClaudeCodeAdapter', () => {
           makeRule({ id: 'bad', trigger: 'on-save' }),
         ],
       });
-      expect(result.files.length).toBeGreaterThan(0);
+      expect(result.files.length).toBe(1);
       expect(result.skipped).toHaveLength(1);
       expect(result.skipped[0].ruleId).toBe('bad');
     });

package/src/engine/core-ops.test.ts

@@ -38,24 +38,6 @@ afterAll(() => {
   runtime.close();
 });
 
-describe('createCoreOps', () => {
-  it('returns exactly 5 ops', () => {
-    const opDefs = createCoreOps(runtime, TEST_IDENTITY);
-    expect(opDefs).toHaveLength(5);
-  });
-
-  it('returns ops with expected names', () => {
-    const names = [...ops.keys()];
-    expect(names).toEqual(['health', 'identity', 'activate', 'session_start', 'setup']);
-  });
-
-  it('all ops have read or write auth level', () => {
-    for (const op of ops.values()) {
-      expect(['read', 'write']).toContain(op.auth);
-    }
-  });
-});
-
 describe('health op', () => {
   it('returns status ok with agent info', async () => {
     const result = await executeOp(ops, 'health');
@@ -75,7 +57,7 @@ describe('health op', () => {
     const data = result.data as Record<string, unknown>;
     const vault = data.vault as Record<string, unknown>;
     expect(typeof vault.entries).toBe('number');
-    expect(Array.isArray(vault.domains)).toBe(true);
+    expect(vault.domains).toEqual([]);
   });
 
   it('has read auth level', () => {
@@ -122,7 +104,7 @@ describe('activate op', () => {
     const vault = data.vault as Record<string, unknown>;
     expect(vault.connected).toBe(true);
     expect(typeof vault.entries).toBe('number');
-    expect(Array.isArray(vault.domains)).toBe(true);
+    expect(vault.domains).toEqual([]);
   });
 
   it('returns deactivation response when deactivate=true', async () => {
@@ -202,8 +184,8 @@ describe('setup op', () => {
     const data = result.data as Record<string, unknown>;
     const vault = data.vault as Record<string, unknown>;
     expect(typeof vault.entries).toBe('number');
-    expect(Array.isArray(vault.domains)).toBe(true);
-    expect(vault.byType).toBeDefined();
+    expect(vault.domains).toEqual([]);
+    expect(vault.byType).toEqual({});
   });
 
   it('recommends action when vault is empty', async () => {

package/src/engine/core-ops.ts

@@ -8,10 +8,31 @@
  * Now they're created dynamically by the engine at startup.
  */
 
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from '../runtime/types.js';
 
+function getCoreVersion(): string {
+  try {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    let dir = thisDir;
+    for (let i = 0; i < 5; i++) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+        return pkg.version ?? 'unknown';
+      } catch {
+        dir = dirname(dir);
+      }
+    }
+  } catch {
+    // import.meta.url unavailable in some test envs
+  }
+  return 'unknown';
+}
+
 export interface AgentIdentityConfig {
   id: string;
   name: string;
@@ -38,10 +59,24 @@ export function createCoreOps(
       auth: 'read',
       handler: async () => {
         const s = runtime.vault.stats();
+        let vaultConnected = true;
+        try {
+          runtime.vault.stats();
+        } catch {
+          vaultConnected = false;
+        }
+        const runtimeAny = runtime as unknown as Record<string, unknown>;
+        const brainReady = typeof runtimeAny.brain === 'object' && runtimeAny.brain !== null;
         return {
           status: 'ok',
+          version: getCoreVersion(),
           agent: { name: identity.name, role: identity.role, format: 'filetree' },
-          vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
+          vault: {
+            connected: vaultConnected,
+            entries: s.totalEntries,
+            domains: Object.keys(s.byDomain),
+          },
+          brain: { ready: brainReady },
         };
       },
     },

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

@@ -6,12 +6,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import {
-  ENGINE_MODULE_MANIFEST,
-  CORE_KEY_OPS,
-  ENGINE_MAJOR_VERSION,
-  type ModuleManifestEntry,
-} from './module-manifest.js';
+import { ENGINE_MODULE_MANIFEST, CORE_KEY_OPS, ENGINE_MAJOR_VERSION } from './module-manifest.js';
 
 describe('ENGINE_MODULE_MANIFEST', () => {
   it('contains all expected engine modules', () => {
@@ -32,10 +27,6 @@ describe('ENGINE_MODULE_MANIFEST', () => {
     expect(suffixes).toContain('intake');
   });
 
-  it('has exactly 22 modules', () => {
-    expect(ENGINE_MODULE_MANIFEST).toHaveLength(22);
-  });
-
   it('has no duplicate suffixes', () => {
     const suffixes = ENGINE_MODULE_MANIFEST.map((m) => m.suffix);
     expect(new Set(suffixes).size).toBe(suffixes.length);
@@ -86,16 +77,6 @@ describe('ENGINE_MODULE_MANIFEST', () => {
     }
   });
 
-  it('satisfies ModuleManifestEntry interface shape', () => {
-    const testEntry: ModuleManifestEntry = {
-      suffix: 'test',
-      description: 'Test module',
-      keyOps: ['op1'],
-    };
-    expect(testEntry.suffix).toBe('test');
-    expect(testEntry.conditional).toBeUndefined();
-  });
-
   it('intentSignals is optional and a Record<string, string> when present', () => {
     for (const entry of ENGINE_MODULE_MANIFEST) {
       if (entry.intentSignals !== undefined) {
@@ -144,20 +125,9 @@ describe('CORE_KEY_OPS', () => {
   it('contains the 4 core ops', () => {
     expect(CORE_KEY_OPS).toEqual(['health', 'identity', 'session_start', 'activate']);
   });
-
-  it('is a string array', () => {
-    for (const op of CORE_KEY_OPS) {
-      expect(typeof op).toBe('string');
-    }
-  });
 });
 
 describe('ENGINE_MAJOR_VERSION', () => {
-  it('is a positive integer', () => {
-    expect(Number.isInteger(ENGINE_MAJOR_VERSION)).toBe(true);
-    expect(ENGINE_MAJOR_VERSION).toBeGreaterThan(0);
-  });
-
   it('is currently version 9', () => {
     expect(ENGINE_MAJOR_VERSION).toBe(9);
   });

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

@@ -63,10 +63,6 @@ describe('registerEngine — module completeness', () => {
     expect(moduleSuffixes).toEqual(manifestSuffixes);
   });
 
-  it('ENGINE_MODULES and manifest have same count', () => {
-    expect(ENGINE_MODULES.length).toBe(ENGINE_MODULE_MANIFEST.length);
-  });
-
   it('registers all unconditional modules', () => {
     const server = makeServer();
     const result = registerEngine(server, runtime, { agentId: 'check' });
@@ -203,10 +199,9 @@ describe('registerEngine — return value', () => {
   it('returns tools array, totalOps count, and registerTool function', () => {
     const server = makeServer();
     const result = registerEngine(server, runtime, { agentId: 'ret' });
-    expect(Array.isArray(result.tools)).toBe(true);
+    expect(result.tools.length).toBeGreaterThan(0);
     expect(typeof result.totalOps).toBe('number');
     expect(typeof result.registerTool).toBe('function');
-    expect(result.totalOps).toBeGreaterThan(0);
   });
 
   it('registerTool adds a new tool at runtime', () => {
@@ -247,8 +242,8 @@ describe('registerEngine — op visibility', () => {
     expect(INTERNAL_OPS.has('create_plan')).toBe(false);
   });
 
-  it('INTERNAL_OPS has at least 25 entries', () => {
-    expect(INTERNAL_OPS.size).toBeGreaterThanOrEqual(25);
+  it('INTERNAL_OPS has exactly 29 entries', () => {
+    expect(INTERNAL_OPS.size).toBe(29);
   });
 
   it('ops without visibility field default to user (backward compat)', () => {
@@ -266,31 +261,6 @@ describe('registerEngine — op visibility', () => {
     expect(result.tools).toContain('vis_test');
   });
 
-  it('ops with visibility: internal are excluded from MCP tool description but remain callable', () => {
-    const server = makeServer();
-    const visibleOp: OpDefinition = {
-      name: 'public_op',
-      description: 'Public op',
-      auth: 'read',
-      handler: async () => 'visible',
-    };
-    const internalOp: OpDefinition = {
-      name: 'secret_op',
-      description: 'Internal op',
-      auth: 'admin',
-      visibility: 'internal',
-      handler: async () => 'hidden',
-    };
-    // Register both ops under a pack facade
-    registerEngine(server, runtime, {
-      agentId: 'vt',
-      domainPacks: [{ name: 'test', facades: [{ name: 'check', ops: [visibleOp, internalOp] }] }],
-    });
-    // We can't easily inspect the MCP schema description string, but we verify
-    // that registration succeeds with mixed visibility ops
-    expect(true).toBe(true);
-  });
-
   it('every INTERNAL_OPS entry corresponds to a real op in some facade', () => {
     // Collect all op names across all engine modules
     const allOpNames = new Set<string>();

package/src/errors/retry.test.ts

@@ -33,9 +33,11 @@ describe('shouldRetry', () => {
 });
 
 describe('getRetryDelay', () => {
-  it('should return a positive number', () => {
+  it('should return a non-negative number', () => {
     const delay = getRetryDelay(0, 'fast');
+    expect(typeof delay).toBe('number');
     expect(delay).toBeGreaterThanOrEqual(0);
+    expect(delay).toBeLessThanOrEqual(RETRY_PRESETS.fast.maxIntervalMs * 1.25);
   });
 
   it('should increase with attempt number', () => {

package/src/flows/chain-runner.test.ts

@@ -98,12 +98,6 @@ describe('ChainRunner', () => {
     runner = new ChainRunner(provider);
   });
 
-  it('initializes the chain_instances table on construction', () => {
-    expect(provider.execSql).toHaveBeenCalledWith(
-      expect.stringContaining('CREATE TABLE IF NOT EXISTS chain_instances'),
-    );
-  });
-
   describe('execute', () => {
     it('runs all steps to completion', async () => {
       const dispatch: DispatchFn = vi.fn(async () => ({ result: 'ok' }));

package/src/flows/context-router.test.ts

@@ -11,7 +11,7 @@ import { getFlowOverrides, detectContext } from './context-router.js';
 describe('getFlowOverrides', () => {
   it('returns overrides for BUILD-flow', () => {
     const overrides = getFlowOverrides('BUILD-flow');
-    expect(overrides.length).toBeGreaterThan(0);
+    expect(overrides).toHaveLength(4);
     const contexts = overrides.map((o) => o.context);
     expect(contexts).toContain('small-component');
     expect(contexts).toContain('large-component');
@@ -19,7 +19,7 @@ describe('getFlowOverrides', () => {
 
   it('returns overrides for FIX-flow', () => {
     const overrides = getFlowOverrides('FIX-flow');
-    expect(overrides.length).toBeGreaterThan(0);
+    expect(overrides).toHaveLength(2);
     const contexts = overrides.map((o) => o.context);
     expect(contexts).toContain('design-fix');
     expect(contexts).toContain('a11y-fix');
@@ -27,7 +27,7 @@ describe('getFlowOverrides', () => {
 
   it('returns overrides for REVIEW-flow', () => {
     const overrides = getFlowOverrides('REVIEW-flow');
-    expect(overrides.length).toBeGreaterThan(0);
+    expect(overrides).toHaveLength(2);
     const contexts = overrides.map((o) => o.context);
     expect(contexts).toContain('pr-review');
     expect(contexts).toContain('architecture-review');