@soleri/core 9.14.4 → 9.16.7

package/src/curator/curator.ts

@@ -40,6 +40,10 @@ import {
 import { initializeTables } from './schema.js';
 import { computeHealthAudit, type HealthDataProvider } from './health-audit.js';
 import { enrichEntryMetadata } from './metadata-enricher.js';
+import {
+  computeEditDistance,
+  normalizeTags as normalizeTagsCanonical,
+} from '../vault/tag-normalizer.js';
 
 // ─── Constants ──────────────────────────────────────────────────────
 
@@ -359,15 +363,141 @@ export class Curator {
       if (batch.length < DEFAULT_BATCH_SIZE) break;
       offset += DEFAULT_BATCH_SIZE;
     }
+
+    // Synonym merge: detect tag pairs with edit-distance ≤ 1 and merge lower-frequency into higher
+    const synonymMerges = this.mergeSynonymTags();
+
     return {
       totalEntries,
       groomedCount: totalEntries,
       tagsNormalized,
       staleCount,
       durationMs: Date.now() - start,
+      synonymMerges,
     };
   }
 
+  /**
+   * Detect tag pairs where edit-distance ≤ 1 (e.g. 'workflow'/'workflows') and merge
+   * the lower-frequency tag into the higher-frequency one across all entries.
+   * Returns count of tags merged.
+   */
+  private mergeSynonymTags(): number {
+    // Collect all unique tags and their usage counts
+    const rows = this.provider.all<{ tags: string }>(
+      'SELECT tags FROM entries WHERE tags IS NOT NULL',
+    );
+    const tagCounts = new Map<string, number>();
+
+    for (const row of rows) {
+      let tags: string[];
+      try {
+        tags = JSON.parse(row.tags) as string[];
+      } catch {
+        continue;
+      }
+      for (const tag of tags) {
+        if (typeof tag === 'string' && tag.length > 0) {
+          tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+        }
+      }
+    }
+
+    const allTags = Array.from(tagCounts.keys());
+    if (allTags.length < 2) return 0;
+
+    // Build synonym merge map: minorTag → majorTag
+    // Only merge if edit-distance ≤ 1 and major has higher or equal frequency
+    const mergeMap = new Map<string, string>(); // minor → major
+    const processed = new Set<string>();
+
+    // Bucket tags by length to reduce comparisons from O(n²) to O(n * avg_bucket_size)
+    const buckets = new Map<number, string[]>();
+    for (const tag of allTags) {
+      const len = tag.length;
+      const bucket = buckets.get(len);
+      if (bucket) {
+        bucket.push(tag);
+      } else {
+        buckets.set(len, [tag]);
+      }
+    }
+
+    for (const a of allTags) {
+      if (processed.has(a)) continue;
+      // Only compare against tags of the same or adjacent length (edit distance ≤ 1)
+      const candidates: string[] = [
+        ...(buckets.get(a.length) ?? []),
+        ...(buckets.get(a.length - 1) ?? []),
+        ...(buckets.get(a.length + 1) ?? []),
+      ];
+      for (const b of candidates) {
+        if (b === a) continue;
+        if (processed.has(a) || processed.has(b)) continue;
+        if (computeEditDistance(a, b) <= 1) {
+          const countA = tagCounts.get(a) ?? 0;
+          const countB = tagCounts.get(b) ?? 0;
+          // Merge lower-frequency into higher-frequency
+          if (countA >= countB) {
+            mergeMap.set(b, a);
+            processed.add(b);
+          } else {
+            mergeMap.set(a, b);
+            processed.add(a);
+          }
+        }
+      }
+    }
+
+    if (mergeMap.size === 0) return 0;
+
+    // Apply merges to all affected entries
+    let mergeCount = 0;
+    const allEntryRows = this.provider.all<{ id: string; tags: string }>(
+      'SELECT id, tags FROM entries WHERE tags IS NOT NULL',
+    );
+
+    for (const row of allEntryRows) {
+      let tags: string[];
+      try {
+        tags = JSON.parse(row.tags) as string[];
+      } catch {
+        continue;
+      }
+
+      let changed = false;
+      const updated = [
+        ...new Set(
+          tags.map((tag) => {
+            const replacement = mergeMap.get(tag);
+            if (replacement) {
+              changed = true;
+              return replacement;
+            }
+            return tag;
+          }),
+        ),
+      ];
+
+      if (changed) {
+        this.provider.run('UPDATE entries SET tags = ?, updated_at = unixepoch() WHERE id = ?', [
+          JSON.stringify(updated),
+          row.id,
+        ]);
+        this.logChange(
+          'synonym_merge',
+          row.id,
+          JSON.stringify(tags),
+          JSON.stringify(updated),
+          'Synonym tag merge (edit-distance ≤ 1)',
+        );
+        mergeCount++;
+      }
+    }
+
+    return mergeCount;
+  }
+
   // ─── Consolidation ───────────────────────────────────────────
 
   consolidate(options?: ConsolidationOptions): ConsolidationResult {
@@ -419,6 +549,55 @@ export class Curator {
         }
       }
     }
+
+    // Retag: run all entries through canonical normalization if requested
+    let retagged: number | undefined;
+    if (options?.retag && options.canonicalTags && options.canonicalTags.length > 0) {
+      const tagMode = options.tagConstraintMode ?? 'suggest';
+      const metaPrefixes = options.metadataTagPrefixes ?? ['source:'];
+      retagged = 0;
+
+      const entryRows = this.provider.all<{ id: string; tags: string }>(
+        'SELECT id, tags FROM entries WHERE tags IS NOT NULL',
+      );
+
+      for (const row of entryRows) {
+        let tags: string[];
+        try {
+          tags = JSON.parse(row.tags) as string[];
+        } catch {
+          continue;
+        }
+
+        const normalized = normalizeTagsCanonical(
+          tags,
+          options.canonicalTags,
+          tagMode,
+          metaPrefixes,
+        );
+        const tagsChanged =
+          normalized.length !== tags.length || normalized.some((t, i) => t !== tags[i]);
+
+        if (tagsChanged) {
+          if (!dryRun) {
+            this.provider.run(
+              'UPDATE entries SET tags = ?, updated_at = unixepoch() WHERE id = ?',
+              [JSON.stringify(normalized), row.id],
+            );
+            this.logChange(
+              'retag',
+              row.id,
+              JSON.stringify(tags),
+              JSON.stringify(normalized),
+              'Canonical retag during consolidation',
+            );
+            mutations++;
+          }
+          retagged++;
+        }
+      }
+    }
+
     return {
       dryRun,
       duplicates,
@@ -426,6 +605,7 @@ export class Curator {
       contradictions,
       mutations,
       durationMs: Date.now() - start,
+      retagged,
     };
   }
 

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/curator/types.ts

@@ -62,6 +62,7 @@ export interface GroomAllResult {
   tagsNormalized: number;
   staleCount: number;
   durationMs: number;
+  synonymMerges: number;
 }
 
 // ─── Consolidation ──────────────────────────────────────────────────
@@ -71,6 +72,14 @@ export interface ConsolidationOptions {
   staleDaysThreshold?: number;
   duplicateThreshold?: number;
   contradictionThreshold?: number;
+  /** When true, run all entries through canonical tag normalization. Dry-run by default. */
+  retag?: boolean;
+  /** Canonical tag list for retag operation. Required when retag is true. */
+  canonicalTags?: string[];
+  /** Tag constraint mode for retag. Default: 'suggest'. */
+  tagConstraintMode?: 'enforce' | 'suggest' | 'off';
+  /** Metadata tag prefixes exempt from canonical normalization. Default: ['source:']. */
+  metadataTagPrefixes?: string[];
 }
 
 export interface ConsolidationResult {
@@ -80,6 +89,7 @@ export interface ConsolidationResult {
   contradictions: Contradiction[];
   mutations: number;
   durationMs: number;
+  retagged?: number;
 }
 
 // ─── Changelog & Health ─────────────────────────────────────────────

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');

package/src/flows/epilogue.test.ts

@@ -2,11 +2,13 @@
  * Epilogue — colocated contract tests.
  *
  * Contract:
- * - runEpilogue() calls capture_knowledge when vault is available
+ * - runEpilogue() calls capture_knowledge with intent-specific title when vault is available
  * - runEpilogue() calls session_capture when sessionStore is available
  * - Returns { captured: true, sessionId } on success
  * - Silently ignores errors from dispatch (best-effort)
  * - Returns { captured: false } when no probes are available
+ * - Title format: "{INTENT} execution — {objective}" (max 120 chars)
+ * - Tags include intent (lowercase) and domain (if provided)
  */
 
 import { describe, it, expect, vi } from 'vitest';
@@ -33,7 +35,6 @@ describe('runEpilogue', () => {
     expect(dispatch).toHaveBeenCalledWith(
       'capture_knowledge',
       expect.objectContaining({
-        title: 'Flow execution summary',
         content: 'summary',
         type: 'workflow',
         projectPath: '/project',
@@ -42,6 +43,43 @@ describe('runEpilogue', () => {
     expect(result.captured).toBe(true);
   });
 
+  it('uses intent-specific title when planContext is provided', async () => {
+    const dispatch = vi.fn(async () => ({ tool: 'capture_knowledge', status: 'ok', data: {} }));
+    await runEpilogue(dispatch, probes({ vault: true }), '/project', 'summary', {
+      intent: 'BUILD',
+      objective: 'add authentication module',
+      domain: 'auth',
+    });
+
+    expect(dispatch).toHaveBeenCalledWith(
+      'capture_knowledge',
+      expect.objectContaining({
+        title: 'BUILD execution — add authentication module',
+        tags: expect.arrayContaining(['auto-captured', 'build', 'auth']),
+      }),
+    );
+  });
+
+  it('falls back to FLOW intent when planContext is absent', async () => {
+    const dispatch = vi.fn(async () => ({ tool: 'capture_knowledge', status: 'ok', data: {} }));
+    await runEpilogue(dispatch, probes({ vault: true }), '/project', 'done summary');
+
+    const call = dispatch.mock.calls[0]?.[1] as Record<string, unknown>;
+    expect((call.title as string).startsWith('FLOW execution —')).toBe(true);
+    expect((call.tags as string[]).includes('flow')).toBe(true);
+  });
+
+  it('omits domain tag when domain is not provided', async () => {
+    const dispatch = vi.fn(async () => ({ tool: 'capture_knowledge', status: 'ok', data: {} }));
+    await runEpilogue(dispatch, probes({ vault: true }), '/project', 'summary', {
+      intent: 'FIX',
+      objective: 'fix login bug',
+    });
+
+    const call = dispatch.mock.calls[0]?.[1] as Record<string, unknown>;
+    expect(call.tags).toEqual(['auto-captured', 'fix']);
+  });
+
   it('captures session when sessionStore is available', async () => {
     const dispatch = vi.fn(async () => ({
       tool: 'session_capture',