@dot-ai/core 0.5.2

package/dist/nodes.js

@@ -0,0 +1,46 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Discover all .ai/ directories in a workspace.
+ * Always includes root. Scans configurable directories for sub-nodes.
+ *
+ * @param root - workspace root (absolute path)
+ * @param scanDirs - directories to scan for sub-nodes (default: ["projects"])
+ */
+export function discoverNodes(root, scanDirs = ['projects']) {
+    const nodes = [
+        { name: 'root', path: join(root, '.ai'), root: true },
+    ];
+    for (const dir of scanDirs) {
+        const scanPath = join(root, dir);
+        try {
+            const entries = readdirSync(scanPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const aiPath = join(scanPath, entry.name, '.ai');
+                try {
+                    readdirSync(aiPath); // existence check
+                    nodes.push({ name: entry.name, path: aiPath, root: false });
+                }
+                catch {
+                    // No .ai/ in this directory
+                }
+            }
+        }
+        catch {
+            // Scan directory doesn't exist
+        }
+    }
+    return nodes;
+}
+/**
+ * Parse scanDirs from a config string value.
+ * Returns empty array if not configured.
+ */
+export function parseScanDirs(value) {
+    if (!value || typeof value !== 'string')
+        return [];
+    return value.split(',').map(s => s.trim()).filter(Boolean);
+}
+//# sourceMappingURL=nodes.js.map

package/dist/nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../src/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,WAAqB,CAAC,UAAU,CAAC;IAC3E,MAAM,KAAK,GAAW;QACpB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;KACtD,CAAC;IAEF,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,WAAW,CAAC,QAAQ,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YAC/D,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;gBAC5B,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;oBAAE,SAAS;gBACnC,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACjD,IAAI,CAAC;oBACH,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,kBAAkB;oBACvC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;gBAC9D,CAAC;gBAAC,MAAM,CAAC;oBACP,4BAA4B;gBAC9B,CAAC;YACH,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,+BAA+B;QACjC,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACnD,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAC7D,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * A label is a boolean tag matched against the prompt.
+ * No scores — matched or not.
+ */
+export interface Label {
+    name: string;
+    source: string;
+}
+/**
+ * A workspace node — a directory containing .ai/ context.
+ * Root node is always included. Sub-nodes are discovered via scanDirs.
+ */
+export interface Node {
+    name: string;
+    path: string;
+    root: boolean;
+}
+export interface MemoryEntry {
+    content: string;
+    type: string;
+    source: string;
+    date?: string;
+    labels?: string[];
+    node?: string;
+}
+export interface Skill {
+    name: string;
+    description: string;
+    labels: string[];
+    triggers?: string[];
+    path?: string;
+    content?: string;
+    dependsOn?: string[];
+    requiresTools?: string[];
+    enabled?: boolean;
+    node?: string;
+}
+export interface Identity {
+    type: string;
+    content: string;
+    source: string;
+    priority: number;
+    node?: string;
+}
+export interface Task {
+    id: string;
+    text: string;
+    status: string;
+    priority?: string;
+    project?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    labels: string[];
+    config: Record<string, unknown>;
+    source: string;
+    node?: string;
+}
+export interface RoutingResult {
+    model: string;
+    reason: string;
+    fallback?: string;
+}
+/**
+ * The output of the enrich() call.
+ * This is what adapters consume to inject into the agent.
+ */
+export interface EnrichedContext {
+    prompt: string;
+    labels: Label[];
+    identities: Identity[];
+    memories: MemoryEntry[];
+    skills: Skill[];
+    tools: Tool[];
+    routing: RoutingResult;
+}
+/**
+ * Filter for task queries
+ */
+export interface TaskFilter {
+    status?: string;
+    project?: string;
+    tags?: string[];
+}
+/**
+ * Configuration from dot-ai.yml
+ */
+export interface DebugConfig {
+    logPath?: string;
+}
+export interface WorkspaceConfig {
+    scanDirs?: string;
+}
+export interface DotAiConfig {
+    memory?: ProviderConfig;
+    skills?: ProviderConfig;
+    identity?: ProviderConfig;
+    routing?: ProviderConfig;
+    tasks?: ProviderConfig;
+    tools?: ProviderConfig;
+    debug?: DebugConfig;
+    workspace?: WorkspaceConfig;
+}
+export interface ProviderConfig {
+    use: string;
+    with?: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@dot-ai/core",
+  "version": "0.5.2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jogelin/dot-ai",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  }
+}

package/src/__tests__/config.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mkdtemp, writeFile, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadConfig, resolveConfig } from '../config.js';
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = await mkdtemp(join(tmpdir(), 'dot-ai-test-'));
+  await mkdir(join(testDir, '.ai'), { recursive: true });
+});
+
+describe('loadConfig', () => {
+  it('returns empty config when no file exists', async () => {
+    const config = await loadConfig(testDir);
+    expect(config).toEqual({});
+  });
+
+  it('returns empty config when .ai directory has no dot-ai.yml', async () => {
+    const config = await loadConfig('/nonexistent/path/to/workspace');
+    expect(config).toEqual({});
+  });
+
+  it('parses a simple memory section', async () => {
+    await writeFile(
+      join(testDir, '.ai', 'dot-ai.yml'),
+      `memory:\n  use: @dot-ai/provider-file-memory\n`,
+      'utf-8',
+    );
+    const config = await loadConfig(testDir);
+    expect(config.memory).toEqual({ use: '@dot-ai/provider-file-memory' });
+  });
+
+  it('parses multiple provider sections', async () => {
+    await writeFile(
+      join(testDir, '.ai', 'dot-ai.yml'),
+      [
+        'memory:',
+        '  use: @dot-ai/provider-file-memory',
+        'skills:',
+        '  use: @dot-ai/provider-file-skills',
+        'routing:',
+        '  use: @dot-ai/provider-rules-routing',
+      ].join('\n'),
+      'utf-8',
+    );
+    const config = await loadConfig(testDir);
+    expect(config.memory?.use).toBe('@dot-ai/provider-file-memory');
+    expect(config.skills?.use).toBe('@dot-ai/provider-file-skills');
+    expect(config.routing?.use).toBe('@dot-ai/provider-rules-routing');
+  });
+
+  it('parses nested with block', async () => {
+    await writeFile(
+      join(testDir, '.ai', 'dot-ai.yml'),
+      [
+        'memory:',
+        '  use: @dot-ai/cockpit-memory',
+        '    url: http://localhost:3010',
+      ].join('\n'),
+      'utf-8',
+    );
+    const config = await loadConfig(testDir);
+    expect(config.memory?.use).toBe('@dot-ai/cockpit-memory');
+    expect(config.memory?.with?.['url']).toBe('http://localhost:3010');
+  });
+
+  it('resolves ${ENV_VAR} references', async () => {
+    process.env['DOT_AI_TEST_URL'] = 'http://test-server:9999';
+    await writeFile(
+      join(testDir, '.ai', 'dot-ai.yml'),
+      [
+        'memory:',
+        '  use: @dot-ai/cockpit-memory',
+        '    url: ${DOT_AI_TEST_URL}',
+      ].join('\n'),
+      'utf-8',
+    );
+    const config = await loadConfig(testDir);
+    expect(config.memory?.with?.['url']).toBe('http://test-server:9999');
+    delete process.env['DOT_AI_TEST_URL'];
+  });
+
+  it('replaces undefined ENV_VAR with empty string', async () => {
+    delete process.env['MISSING_ENV_VAR'];
+    await writeFile(
+      join(testDir, '.ai', 'dot-ai.yml'),
+      [
+        'memory:',
+        '  use: @dot-ai/provider-file-memory',
+        '    key: ${MISSING_ENV_VAR}',
+      ].join('\n'),
+      'utf-8',
+    );
+    const config = await loadConfig(testDir);
+    expect(config.memory?.with?.['key']).toBe('');
+  });
+
+  it('skips comment lines (# prefix)', async () => {
+    await writeFile(
+      join(testDir, '.ai', 'dot-ai.yml'),
+      [
+        '# This is a comment',
+        'memory:',
+        '  # nested comment',
+        '  use: @dot-ai/provider-file-memory',
+      ].join('\n'),
+      'utf-8',
+    );
+    const config = await loadConfig(testDir);
+    expect(config.memory?.use).toBe('@dot-ai/provider-file-memory');
+  });
+});
+
+describe('resolveConfig', () => {
+  it('fills all defaults for empty config', () => {
+    const resolved = resolveConfig({});
+    expect(resolved.memory.use).toBe('@dot-ai/provider-file-memory');
+    expect(resolved.skills.use).toBe('@dot-ai/provider-file-skills');
+    expect(resolved.identity.use).toBe('@dot-ai/provider-file-identity');
+    expect(resolved.routing.use).toBe('@dot-ai/provider-rules-routing');
+    expect(resolved.tasks.use).toBe('@dot-ai/provider-file-tasks');
+    expect(resolved.tools.use).toBe('@dot-ai/provider-file-tools');
+  });
+
+  it('preserves existing memory config', () => {
+    const resolved = resolveConfig({ memory: { use: '@dot-ai/cockpit-memory', with: { url: 'http://x' } } });
+    expect(resolved.memory.use).toBe('@dot-ai/cockpit-memory');
+    expect(resolved.memory.with?.['url']).toBe('http://x');
+  });
+
+  it('fills defaults only for missing providers', () => {
+    const resolved = resolveConfig({ memory: { use: '@dot-ai/cockpit-memory' } });
+    expect(resolved.memory.use).toBe('@dot-ai/cockpit-memory');
+    expect(resolved.skills.use).toBe('@dot-ai/provider-file-skills');
+    expect(resolved.routing.use).toBe('@dot-ai/provider-rules-routing');
+  });
+
+  it('returns a Required<DotAiConfig> with all keys present', () => {
+    const resolved = resolveConfig({});
+    const keys = ['memory', 'skills', 'identity', 'routing', 'tasks', 'tools'] as const;
+    for (const key of keys) {
+      expect(resolved[key]).toBeDefined();
+      expect(typeof resolved[key].use).toBe('string');
+    }
+  });
+
+  it('preserves all six provided providers', () => {
+    const full = {
+      memory: { use: 'mem' },
+      skills: { use: 'ski' },
+      identity: { use: 'idn' },
+      routing: { use: 'rte' },
+      tasks: { use: 'tsk' },
+      tools: { use: 'tls' },
+    };
+    const resolved = resolveConfig(full);
+    expect(resolved.memory.use).toBe('mem');
+    expect(resolved.skills.use).toBe('ski');
+    expect(resolved.identity.use).toBe('idn');
+    expect(resolved.routing.use).toBe('rte');
+    expect(resolved.tasks.use).toBe('tsk');
+    expect(resolved.tools.use).toBe('tls');
+  });
+});

package/src/__tests__/e2e.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  loadConfig,
+  resolveConfig,
+  registerDefaults,
+  clearProviders,
+  createProviders,
+  boot,
+  enrich,
+  learn,
+} from '../index.js';
+
+describe('E2E: full pipeline', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    clearProviders();
+    registerDefaults();
+
+    root = await mkdtemp(join(tmpdir(), 'dot-ai-e2e-'));
+    const ai = join(root, '.ai');
+
+    // Create .ai/ structure
+    await mkdir(ai, { recursive: true });
+    await mkdir(join(ai, 'memory'), { recursive: true });
+    await mkdir(join(ai, 'skills', 'ts-standards'), { recursive: true });
+    await mkdir(join(ai, 'skills', 'code-review'), { recursive: true });
+    await mkdir(join(ai, 'tools'), { recursive: true });
+
+    // Identity files
+    await writeFile(join(ai, 'AGENTS.md'), '# AGENTS.md\n\nYou are Kiwi, a helpful assistant.\n\n## Rules\n- Always be concise\n- Use TypeScript');
+    await writeFile(join(ai, 'SOUL.md'), '# SOUL.md\n\nBe genuine. Skip the fluff.');
+    await writeFile(join(ai, 'USER.md'), '# USER.md\n\nJo, developer, Belgium.');
+    await writeFile(join(ai, 'IDENTITY.md'), '# IDENTITY.md\n\nName: Kiwi\nEmoji: 🥝');
+
+    // Skills with frontmatter
+    await writeFile(join(ai, 'skills', 'ts-standards', 'SKILL.md'), [
+      '---',
+      'description: TypeScript coding standards',
+      'labels: [typescript, code, standards]',
+      'triggers: [auto]',
+      '---',
+      '',
+      '## TypeScript Standards',
+      '',
+      '- Use strict mode',
+      '- Prefer const over let',
+      '- Add type annotations',
+    ].join('\n'));
+
+    await writeFile(join(ai, 'skills', 'code-review', 'SKILL.md'), [
+      '---',
+      'description: Code review guidelines',
+      'labels: [review, code-fix, bug]',
+      'triggers: [auto]',
+      '---',
+      '',
+      '## Code Review',
+      '',
+      '- Check for edge cases',
+      '- Verify error handling',
+    ].join('\n'));
+
+    // Tools
+    await writeFile(join(ai, 'tools', 'eslint.yaml'), [
+      'name: eslint',
+      'description: TypeScript linter',
+      'labels: [typescript, lint, code]',
+    ].join('\n'));
+
+    // Memory (some past entries)
+    await writeFile(join(ai, 'memory', '2026-03-01.md'), [
+      '- Fixed auth middleware N+1 query bug',
+      '- Decided to use JWT for auth tokens',
+      '- Rate limiting added to auth endpoints',
+    ].join('\n'));
+
+    await writeFile(join(ai, 'memory', '2026-03-02.md'), [
+      '- Refactored database connection pooling',
+      '- Updated React test suite to use vitest',
+    ].join('\n'));
+
+    // Config — uses 4-space indent for 'with' block (parsed as options)
+    // The parser maps 4-space keys directly into section.with
+    await writeFile(join(ai, 'dot-ai.yml'), [
+      '# dot-ai config',
+      'memory:',
+      '  use: @dot-ai/provider-file-memory',
+      `    root: ${root}`,
+      'skills:',
+      '  use: @dot-ai/provider-file-skills',
+      `    root: ${root}`,
+      'identity:',
+      '  use: @dot-ai/provider-file-identity',
+      `    root: ${root}`,
+      'routing:',
+      '  use: @dot-ai/provider-rules-routing',
+      'tasks:',
+      '  use: @dot-ai/provider-file-tasks',
+      `    root: ${root}`,
+      'tools:',
+      '  use: @dot-ai/provider-file-tools',
+      `    root: ${root}`,
+    ].join('\n'));
+  });
+
+  it('runs the complete pipeline: config → providers → boot → enrich', async () => {
+    // 1. Load config
+    const config = await loadConfig(root);
+    expect(config).toBeDefined();
+
+    // 2. Create providers
+    const providers = await createProviders(config);
+    expect(providers).toBeDefined();
+    expect(providers.memory).toBeDefined();
+    expect(providers.skills).toBeDefined();
+    expect(providers.identity).toBeDefined();
+    expect(providers.routing).toBeDefined();
+    expect(providers.tasks).toBeDefined();
+    expect(providers.tools).toBeDefined();
+
+    // 3. Boot
+    const cache = await boot(providers);
+    expect(cache.identities.length).toBe(4); // AGENTS, SOUL, USER, IDENTITY
+    expect(cache.skills.length).toBe(2); // ts-standards, code-review
+    expect(cache.vocabulary.length).toBeGreaterThan(0);
+    expect(cache.vocabulary).toContain('typescript');
+    expect(cache.vocabulary).toContain('code');
+
+    // 4. Enrich a prompt
+    const ctx = await enrich('Fix the TypeScript bug in the auth module', providers, cache);
+
+    // Check labels extracted
+    expect(ctx.labels.length).toBeGreaterThan(0);
+    expect(ctx.labels.some(l => l.name === 'typescript')).toBe(true);
+
+    // Check identities loaded
+    expect(ctx.identities.length).toBe(4);
+    expect(ctx.identities.find(i => i.type === 'agents')?.content).toContain('Kiwi');
+
+    // Check memories found (should match "auth" and/or "bug")
+    expect(ctx.memories.length).toBeGreaterThan(0);
+    expect(ctx.memories.some(m => m.content.includes('auth'))).toBe(true);
+
+    // Check skills matched (typescript label should match ts-standards)
+    expect(ctx.skills.length).toBeGreaterThan(0);
+    expect(ctx.skills.some(s => s.name === 'ts-standards')).toBe(true);
+
+    // Check tools matched (typescript label should match eslint)
+    expect(ctx.tools.length).toBeGreaterThan(0);
+    expect(ctx.tools.some(t => t.name === 'eslint')).toBe(true);
+
+    // Check routing (code-fix → sonnet)
+    expect(ctx.routing.model).toBeDefined();
+  });
+
+  it('enriches differently for different prompts', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    // A code-related prompt should match code skills and tools
+    const codeFix = await enrich('Fix the TypeScript bug', providers, cache);
+    expect(codeFix.skills.some(s => s.name === 'ts-standards')).toBe(true);
+    expect(codeFix.tools.some(t => t.name === 'eslint')).toBe(true);
+
+    // A review-related prompt should match code-review skill
+    const review = await enrich('Review this code for bugs', providers, cache);
+    expect(review.skills.some(s => s.name === 'code-review')).toBe(true);
+  });
+
+  it('learns from agent responses and retrieves later', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    // Learn something
+    await learn('Discovered that the connection pool was configured wrong', providers);
+
+    // Should be retrievable via memory search
+    const ctx = await enrich('What about the connection pool?', providers, cache);
+    expect(ctx.memories.some(m => m.content.includes('connection pool'))).toBe(true);
+  });
+
+  it('works with empty .ai/ directory (minimal config)', async () => {
+    const emptyRoot = await mkdtemp(join(tmpdir(), 'dot-ai-empty-'));
+    await mkdir(join(emptyRoot, '.ai'), { recursive: true });
+    await writeFile(join(emptyRoot, '.ai', 'dot-ai.yml'), '# empty config');
+
+    const config = await loadConfig(emptyRoot);
+    // Inject root so providers read from the empty dir (not process.cwd())
+    const resolvedConfig = {
+      memory: { use: '@dot-ai/provider-file-memory', with: { root: emptyRoot } },
+      skills: { use: '@dot-ai/provider-file-skills', with: { root: emptyRoot } },
+      identity: { use: '@dot-ai/provider-file-identity', with: { root: emptyRoot } },
+      routing: { use: '@dot-ai/provider-rules-routing' },
+      tasks: { use: '@dot-ai/provider-file-tasks', with: { root: emptyRoot } },
+      tools: { use: '@dot-ai/provider-file-tools', with: { root: emptyRoot } },
+      ...config,
+    };
+    const providers = await createProviders(resolvedConfig);
+    const cache = await boot(providers);
+
+    expect(cache.identities).toEqual([]);
+    expect(cache.skills).toEqual([]);
+    expect(cache.vocabulary).toEqual([]);
+
+    const ctx = await enrich('Hello', providers, cache);
+    expect(ctx.identities).toEqual([]);
+    expect(ctx.memories).toEqual([]);
+    expect(ctx.skills).toEqual([]);
+  });
+
+  it('unregistered provider falls back to noop gracefully', async () => {
+    // Auto-discovery: when a provider name is not in the registry and cannot be
+    // dynamically imported (e.g. package doesn't exist), createProviders must
+    // return a working noop instead of throwing.
+    clearProviders(); // no defaults registered
+    const providers = await createProviders({
+      memory: { use: '@dot-ai/nonexistent-memory-provider' },
+    });
+    // Should not throw — noop memory is returned
+    const memories = await providers.memory.search('anything');
+    expect(memories).toEqual([]);
+    await expect(
+      providers.memory.store({ content: 'x', type: 'log' }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('boot caches skills and vocabulary for reuse across prompts', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    // Run enrich multiple times — should all use same cache
+    const ctx1 = await enrich('Fix typescript', providers, cache);
+    const ctx2 = await enrich('Review code', providers, cache);
+    const ctx3 = await enrich('Something unrelated', providers, cache);
+
+    // All should have same identities from cache
+    expect(ctx1.identities).toEqual(ctx2.identities);
+    expect(ctx2.identities).toEqual(ctx3.identities);
+  });
+
+  it('resolveConfig fills defaults for missing providers', () => {
+    const resolved = resolveConfig({});
+    expect(resolved.memory.use).toBe('@dot-ai/provider-file-memory');
+    expect(resolved.skills.use).toBe('@dot-ai/provider-file-skills');
+    expect(resolved.identity.use).toBe('@dot-ai/provider-file-identity');
+    expect(resolved.routing.use).toBe('@dot-ai/provider-rules-routing');
+    expect(resolved.tasks.use).toBe('@dot-ai/provider-file-tasks');
+    expect(resolved.tools.use).toBe('@dot-ai/provider-file-tools');
+  });
+});