@soleri/core 9.0.4 → 9.3.0

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

@@ -0,0 +1,254 @@
+/**
+ * Colocated tests for core-ops.ts
+ *
+ * Validates createCoreOps() — the 5 agent-specific ops:
+ * health, identity, activate, session_start, setup.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createCoreOps, type AgentIdentityConfig } from './core-ops.js';
+import { captureOps, executeOp } from './test-helpers.js';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { CapturedOp } from './test-helpers.js';
+
+const TEST_IDENTITY: AgentIdentityConfig = {
+  id: 'test-agent',
+  name: 'TestBot',
+  role: 'Testing Assistant',
+  description: 'An agent for unit testing',
+  domains: ['testing', 'quality'],
+  principles: ['test everything', 'assert precisely'],
+  tone: 'pragmatic',
+  greeting: 'Hello from tests!',
+};
+
+let runtime: AgentRuntime;
+let ops: Map<string, CapturedOp>;
+
+beforeAll(() => {
+  runtime = createAgentRuntime({
+    agentId: 'test-agent',
+    vaultPath: ':memory:',
+  });
+  ops = captureOps(createCoreOps(runtime, TEST_IDENTITY));
+});
+
+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');
+    expect(result.success).toBe(true);
+
+    const data = result.data as Record<string, unknown>;
+    expect(data.status).toBe('ok');
+    expect(data.agent).toEqual({
+      name: 'TestBot',
+      role: 'Testing Assistant',
+      format: 'filetree',
+    });
+  });
+
+  it('includes vault stats', async () => {
+    const result = await executeOp(ops, 'health');
+    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);
+  });
+
+  it('has read auth level', () => {
+    expect(ops.get('health')!.auth).toBe('read');
+  });
+});
+
+describe('identity op', () => {
+  it('returns identity fields from config', async () => {
+    const result = await executeOp(ops, 'identity');
+    expect(result.success).toBe(true);
+
+    const data = result.data as Record<string, unknown>;
+    expect(data.name).toBe('TestBot');
+    expect(data.role).toBe('Testing Assistant');
+    expect(data.description).toBe('An agent for unit testing');
+    expect(data.domains).toEqual(['testing', 'quality']);
+    expect(data.principles).toEqual(['test everything', 'assert precisely']);
+    expect(data.tone).toBe('pragmatic');
+  });
+
+  it('has read auth level', () => {
+    expect(ops.get('identity')!.auth).toBe('read');
+  });
+});
+
+describe('activate op', () => {
+  it('returns activation context when activated', async () => {
+    const result = await executeOp(ops, 'activate', { projectPath: '.' });
+    expect(result.success).toBe(true);
+
+    const data = result.data as Record<string, unknown>;
+    expect(data.activated).toBe(true);
+    expect(data.domains).toEqual(['testing', 'quality']);
+
+    const agent = data.agent as Record<string, unknown>;
+    expect(agent.id).toBe('test-agent');
+    expect(agent.format).toBe('filetree');
+  });
+
+  it('includes vault connection info', async () => {
+    const result = await executeOp(ops, 'activate', { projectPath: '.' });
+    const data = result.data as Record<string, unknown>;
+    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);
+  });
+
+  it('returns deactivation response when deactivate=true', async () => {
+    const result = await executeOp(ops, 'activate', { deactivate: true });
+    expect(result.success).toBe(true);
+
+    const data = result.data as Record<string, unknown>;
+    expect(data.deactivated).toBe(true);
+    expect(data.agent).toBe('test-agent');
+  });
+
+  it('handles default projectPath', async () => {
+    const result = await executeOp(ops, 'activate', {});
+    expect(result.success).toBe(true);
+    const data = result.data as Record<string, unknown>;
+    expect(data.activated).toBe(true);
+  });
+
+  it('offers persona setup when no persona configured', async () => {
+    // Default runtime has persona template 'none' or a default
+    const result = await executeOp(ops, 'activate', {});
+    expect(result.success).toBe(true);
+    const data = result.data as Record<string, unknown>;
+
+    // Either persona or personaSetup should be present
+    const hasPersonaOrSetup = 'persona' in data || 'personaSetup' in data;
+    expect(hasPersonaOrSetup).toBe(true);
+  });
+
+  it('has read auth level', () => {
+    expect(ops.get('activate')!.auth).toBe('read');
+  });
+});
+
+describe('session_start op', () => {
+  it('registers a project path', async () => {
+    const result = await executeOp(ops, 'session_start', { projectPath: '/tmp/test-project' });
+    expect(result.success).toBe(true);
+
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.registered).toBe('boolean');
+  });
+
+  it('handles default projectPath', async () => {
+    const result = await executeOp(ops, 'session_start', {});
+    expect(result.success).toBe(true);
+  });
+
+  it('has write auth level', () => {
+    expect(ops.get('session_start')!.auth).toBe('write');
+  });
+});
+
+describe('setup op', () => {
+  it('returns agent info and vault stats', async () => {
+    const result = await executeOp(ops, 'setup');
+    expect(result.success).toBe(true);
+
+    const data = result.data as Record<string, unknown>;
+    const agent = data.agent as Record<string, unknown>;
+    expect(agent.id).toBe('test-agent');
+    expect(agent.name).toBe('TestBot');
+    expect(agent.format).toBe('filetree');
+  });
+
+  it('returns engine capabilities', async () => {
+    const result = await executeOp(ops, 'setup');
+    const data = result.data as Record<string, unknown>;
+    const engine = data.engine as Record<string, unknown>;
+    expect(engine.brain).toBe(true);
+    expect(engine.curator).toBe(true);
+    expect(engine.planner).toBe(true);
+  });
+
+  it('returns vault domain and type breakdown', async () => {
+    const result = await executeOp(ops, 'setup');
+    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();
+  });
+
+  it('recommends action when vault is empty', async () => {
+    const result = await executeOp(ops, 'setup');
+    const data = result.data as Record<string, unknown>;
+    const recommendations = data.recommendations as string[];
+    expect(Array.isArray(recommendations)).toBe(true);
+
+    // Empty vault should yield a recommendation
+    const stats = runtime.vault.stats();
+    if (stats.totalEntries === 0) {
+      expect(recommendations.length).toBe(1);
+      expect(recommendations[0]).toContain('Vault is empty');
+    } else {
+      expect(recommendations).toHaveLength(0);
+    }
+  });
+
+  it('has read auth level', () => {
+    expect(ops.get('setup')!.auth).toBe('read');
+  });
+});
+
+describe('identity with IdentityManager', () => {
+  it('seeds identity on first activation', async () => {
+    // Create a fresh runtime to ensure no identity is seeded yet
+    const freshRuntime = createAgentRuntime({
+      agentId: 'identity-test',
+      vaultPath: ':memory:',
+    });
+
+    const freshOps = captureOps(createCoreOps(freshRuntime, TEST_IDENTITY));
+
+    // Before activation, identity manager should not have this agent
+    const beforeId = freshRuntime.identityManager?.getIdentity(TEST_IDENTITY.id);
+    expect(beforeId).toBeFalsy();
+
+    // Activate seeds identity
+    await executeOp(freshOps, 'activate', { projectPath: '.' });
+
+    const afterId = freshRuntime.identityManager?.getIdentity(TEST_IDENTITY.id);
+    expect(afterId).toBeDefined();
+    expect(afterId!.name).toBe('TestBot');
+    expect(afterId!.role).toBe('Testing Assistant');
+
+    freshRuntime.close();
+  });
+});

package/src/engine/core-ops.ts

@@ -105,13 +105,28 @@ export function createCoreOps(
         const personaInstructions = runtime.personaInstructions;
         const hasPersona = persona.template !== 'none';
 
+        // Check if identity manager has custom identity (updated after initial seed)
+        const customIdentity = runtime.identityManager?.getIdentity(identity.id);
+        const hasCustomIdentity = customIdentity && customIdentity.version > 1;
+
+        const agentName = hasCustomIdentity
+          ? customIdentity.name
+          : hasPersona
+            ? persona.name
+            : identity.name;
+        const agentRole = hasCustomIdentity ? customIdentity.role : identity.role;
+        const agentDescription = hasCustomIdentity
+          ? customIdentity.description
+          : identity.description;
+
         const response: Record<string, unknown> = {
           activated: true,
+          domains: identity.domains,
           agent: {
             id: identity.id,
-            name: hasPersona ? persona.name : identity.name,
-            role: identity.role,
-            description: identity.description,
+            name: agentName,
+            role: agentRole,
+            description: agentDescription,
             format: 'filetree',
           },
           vault: {
@@ -124,10 +139,12 @@ export function createCoreOps(
         if (hasPersona) {
           response.persona = {
             template: persona.template,
-            name: persona.name,
+            name: hasCustomIdentity ? customIdentity.name : persona.name,
             culture: persona.culture,
-            voice: persona.voice,
-            traits: persona.traits,
+            voice: hasCustomIdentity
+              ? customIdentity.personality.join(', ') || persona.voice
+              : persona.voice,
+            traits: hasCustomIdentity ? customIdentity.personality : persona.traits,
             quirks: persona.quirks,
             greeting: personaInstructions.greeting,
             instructions: personaInstructions.instructions,
@@ -157,8 +174,8 @@ export function createCoreOps(
       },
     },
     {
-      name: 'register',
-      description: 'Register a project for context tracking.',
+      name: 'session_start',
+      description: 'Start a session for a project — tracks usage and loads context.',
       auth: 'write',
       schema: z.object({
         projectPath: z.string().default('.'),

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

@@ -0,0 +1,125 @@
+/**
+ * Colocated tests for module-manifest.ts
+ *
+ * Validates the ENGINE_MODULE_MANIFEST structure, CORE_KEY_OPS,
+ * ENGINE_MAJOR_VERSION, and ModuleManifestEntry contract.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  ENGINE_MODULE_MANIFEST,
+  CORE_KEY_OPS,
+  ENGINE_MAJOR_VERSION,
+  type ModuleManifestEntry,
+} from './module-manifest.js';
+
+describe('ENGINE_MODULE_MANIFEST', () => {
+  it('contains all expected engine modules', () => {
+    const suffixes = ENGINE_MODULE_MANIFEST.map((m) => m.suffix);
+    expect(suffixes).toContain('vault');
+    expect(suffixes).toContain('plan');
+    expect(suffixes).toContain('brain');
+    expect(suffixes).toContain('memory');
+    expect(suffixes).toContain('admin');
+    expect(suffixes).toContain('curator');
+    expect(suffixes).toContain('loop');
+    expect(suffixes).toContain('orchestrate');
+    expect(suffixes).toContain('control');
+    expect(suffixes).toContain('context');
+    expect(suffixes).toContain('agency');
+    expect(suffixes).toContain('chat');
+    expect(suffixes).toContain('operator');
+    expect(suffixes).toContain('intake');
+  });
+
+  it('has exactly 20 modules', () => {
+    expect(ENGINE_MODULE_MANIFEST).toHaveLength(20);
+  });
+
+  it('has no duplicate suffixes', () => {
+    const suffixes = ENGINE_MODULE_MANIFEST.map((m) => m.suffix);
+    expect(new Set(suffixes).size).toBe(suffixes.length);
+  });
+
+  it('every entry has required fields with correct types', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      expect(typeof entry.suffix).toBe('string');
+      expect(entry.suffix.length).toBeGreaterThan(0);
+      expect(typeof entry.description).toBe('string');
+      expect(entry.description.length).toBeGreaterThan(0);
+      expect(Array.isArray(entry.keyOps)).toBe(true);
+      expect(entry.keyOps.length).toBeGreaterThan(0);
+      expect(entry.keyOps.length).toBeLessThanOrEqual(4);
+    }
+  });
+
+  it('keyOps are non-empty strings', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      for (const op of entry.keyOps) {
+        expect(typeof op).toBe('string');
+        expect(op.length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('vault module has expected keyOps', () => {
+    const vault = ENGINE_MODULE_MANIFEST.find((m) => m.suffix === 'vault')!;
+    expect(vault.keyOps).toEqual(['search_intelligent', 'capture_knowledge', 'capture_quick']);
+  });
+
+  it('plan module has expected keyOps', () => {
+    const plan = ENGINE_MODULE_MANIFEST.find((m) => m.suffix === 'plan')!;
+    expect(plan.keyOps).toEqual(['create_plan', 'approve_plan', 'plan_split', 'plan_reconcile']);
+  });
+
+  it('conditional field is optional and boolean when present', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      if (entry.conditional !== undefined) {
+        expect(typeof entry.conditional).toBe('boolean');
+      }
+    }
+  });
+
+  it('satisfies ModuleManifestEntry interface shape', () => {
+    const testEntry: ModuleManifestEntry = {
+      suffix: 'test',
+      description: 'Test module',
+      keyOps: ['op1'],
+    };
+    expect(testEntry.suffix).toBe('test');
+    expect(testEntry.conditional).toBeUndefined();
+  });
+});
+
+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);
+  });
+});
+
+describe('manifest order stability', () => {
+  it('vault is the first module (used in tool table generation)', () => {
+    expect(ENGINE_MODULE_MANIFEST[0].suffix).toBe('vault');
+  });
+
+  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, archival.',
+    description: 'Knowledge management — search, CRUD, capture, sharing scope.',
     keyOps: ['search_intelligent', 'capture_knowledge', 'capture_quick'],
   },
   {
@@ -84,10 +84,50 @@ export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
     description: 'Chat transport — session management, response chunking, authentication.',
     keyOps: ['chat_send', 'chat_history', 'chat_session'],
   },
+  {
+    suffix: 'operator',
+    description: 'Operator profile — personality learning, signals, adaptation.',
+    keyOps: ['profile_get', 'signal_accumulate', 'synthesis_check'],
+  },
+  {
+    suffix: 'archive',
+    description: 'Archival, lifecycle, and knowledge maintenance.',
+    keyOps: ['vault_archive', 'vault_restore', 'vault_optimize', 'knowledge_audit'],
+  },
+  {
+    suffix: 'sync',
+    description: 'Git, Obsidian, and pack sync operations.',
+    keyOps: ['vault_git_push', 'vault_git_pull', 'obsidian_sync'],
+  },
+  {
+    suffix: 'review',
+    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) */
-export const CORE_KEY_OPS = ['health', 'identity', 'register', 'activate'];
+export const CORE_KEY_OPS = ['health', 'identity', 'session_start', 'activate'];
 
 /** Engine major version — used for compatibility checks against domain packs. */
 export const ENGINE_MAJOR_VERSION = 9;