@soleri/core 9.0.3 → 9.2.0

package/src/runtime/facades/operator-facade.ts

@@ -0,0 +1,236 @@
+/**
+ * Operator facade — personality learning, signals, adaptation.
+ * Profile CRUD, signal accumulation, synthesis checks, snapshots.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../../facades/types.js';
+import type { AgentRuntime } from '../types.js';
+import type { ProfileSectionKey, ProfileSection } from '../../operator/operator-types.js';
+
+// ─── Schema helpers ──────────────────────────────────────────────────
+
+const sectionEnum = z.enum([
+  'identity',
+  'cognition',
+  'communication',
+  'workingRules',
+  'trustModel',
+  'tasteProfile',
+  'growthEdges',
+  'technicalContext',
+]);
+
+const signalSchema = z.object({
+  id: z.string(),
+  signalType: z.string(),
+  data: z.record(z.unknown()),
+  timestamp: z.string(),
+  sessionId: z.string(),
+  confidence: z.number(),
+  source: z.string().optional(),
+});
+
+// ─── Export helpers ──────────────────────────────────────────────────
+
+function profileToMarkdown(profile: Record<string, unknown>): string {
+  const lines: string[] = ['# Operator Profile', ''];
+  const meta: [string, unknown][] = [];
+  const sections: [string, unknown][] = [];
+
+  for (const [key, value] of Object.entries(profile)) {
+    if (key === 'id' || key === 'operatorId') continue;
+    if (['version', 'sessionCount', 'lastSynthesis', 'createdAt', 'updatedAt'].includes(key)) {
+      meta.push([key, value]);
+    } else {
+      sections.push([key, value]);
+    }
+  }
+
+  // Metadata table
+  if (meta.length > 0) {
+    lines.push('## Metadata', '');
+    lines.push('| Field | Value |', '|-------|-------|');
+    for (const [k, v] of meta) lines.push(`| ${k} | ${v ?? '—'} |`);
+    lines.push('');
+  }
+
+  // Profile sections with evidence extraction
+  for (const [key, value] of sections) {
+    const heading = key.replace(/([A-Z])/g, ' $1').replace(/^./, (c) => c.toUpperCase());
+    lines.push(`## ${heading}`, '');
+    const obj = value as Record<string, unknown>;
+    const evidence = extractEvidence(obj);
+    const content = { ...obj };
+    delete content.evidence;
+    lines.push('```json', JSON.stringify(content, null, 2), '```', '');
+    if (evidence.length > 0) {
+      lines.push(`**Evidence (${evidence.length}):**`, '');
+      for (const e of evidence.slice(0, 10)) {
+        const label = e.source === 'observed' ? '[observed]' : e.source === 'reported' ? '[reported]' : '';
+        lines.push(`- ${label} ${e.summary} (confidence: ${e.confidence}, ${e.timestamp})`);
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function extractEvidence(obj: Record<string, unknown>): Array<{ summary: string; confidence: number; timestamp: string; source?: string }> {
+  const evidence = obj.evidence;
+  if (!Array.isArray(evidence)) return [];
+  return evidence.filter((e) => e && typeof e === 'object' && 'summary' in e) as Array<{ summary: string; confidence: number; timestamp: string; source?: string }>;
+}
+
+// ─── Facade Creator ─────────────────────────────────────────────────
+
+export function createOperatorFacadeOps(runtime: AgentRuntime): OpDefinition[] {
+  const { operatorProfile } = runtime;
+
+  return [
+    {
+      name: 'profile_get',
+      description: 'Get the full operator profile or a specific section.',
+      auth: 'read',
+      schema: z.object({
+        section: sectionEnum.optional().describe('Return only this section'),
+      }),
+      handler: async (params) => {
+        if (params.section) {
+          const section = operatorProfile.getSection(params.section as ProfileSectionKey);
+          return { section: params.section, data: section };
+        }
+        const profile = operatorProfile.getProfile();
+        return { profile };
+      },
+    },
+    {
+      name: 'profile_update_section',
+      description: 'Update a specific profile section with new data.',
+      auth: 'write',
+      schema: z.object({
+        section: sectionEnum.describe('Section to update'),
+        data: z.record(z.unknown()).describe('New section data'),
+        evidence: z.array(z.string()).optional().describe('Evidence trail'),
+      }),
+      handler: async (params) => {
+        const updated = operatorProfile.updateSection(
+          params.section as ProfileSectionKey,
+          params.data as ProfileSection,
+        );
+        const profile = operatorProfile.getProfile();
+        return { updated, section: params.section, version: profile?.version ?? 0 };
+      },
+    },
+    {
+      name: 'profile_correct',
+      description: 'Correct a profile section — takes a snapshot before overwriting.',
+      auth: 'write',
+      schema: z.object({
+        section: sectionEnum.describe('Section to correct'),
+        data: z.record(z.unknown()).describe('Corrected section data'),
+        reason: z.string().describe('Reason for correction'),
+      }),
+      handler: async (params) => {
+        const corrected = operatorProfile.correctSection(
+          params.section as ProfileSectionKey,
+          params.data as ProfileSection,
+        );
+        const profile = operatorProfile.getProfile();
+        return { corrected, section: params.section, version: profile?.version ?? 0 };
+      },
+    },
+    {
+      name: 'profile_delete',
+      description: 'Delete the operator profile (takes a snapshot first). Admin only.',
+      auth: 'admin',
+      schema: z.object({
+        section: sectionEnum.optional().describe('Unused — deletes entire profile'),
+      }),
+      handler: async () => {
+        const deleted = operatorProfile.deleteProfile();
+        return { deleted, message: deleted ? 'Profile deleted' : 'No profile to delete' };
+      },
+    },
+    {
+      name: 'profile_export',
+      description: 'Export the operator profile as markdown or JSON string.',
+      auth: 'read',
+      schema: z.object({
+        format: z.enum(['markdown', 'json']).optional().default('json'),
+      }),
+      handler: async (params) => {
+        const profile = operatorProfile.getProfile();
+        if (!profile) return { exported: false, reason: 'No profile exists' };
+        const profileObj = profile as unknown as Record<string, unknown>;
+        if (params.format === 'markdown') {
+          return { exported: true, format: 'markdown', content: profileToMarkdown(profileObj) };
+        }
+        return { exported: true, format: 'json', content: JSON.stringify(profile, null, 2) };
+      },
+    },
+    {
+      name: 'signal_accumulate',
+      description: 'Accumulate operator signals for later synthesis.',
+      auth: 'write',
+      schema: z.object({
+        signals: z.array(signalSchema).describe('Signals to store'),
+      }),
+      handler: async (params) => {
+        const count = operatorProfile.accumulateSignals(params.signals as never);
+        return { stored: count };
+      },
+    },
+    {
+      name: 'signal_list',
+      description: 'List operator signals with optional filters.',
+      auth: 'read',
+      schema: z.object({
+        types: z.array(z.string()).optional().describe('Filter by signal types'),
+        processed: z.boolean().optional().describe('Filter by processed status'),
+        limit: z.number().optional().describe('Max results (default 100)'),
+      }),
+      handler: async (params) => {
+        const signals = operatorProfile.listSignals({
+          types: params.types as string[] | undefined,
+          processed: params.processed as boolean | undefined,
+          limit: params.limit as number | undefined,
+        });
+        return { signals, count: signals.length };
+      },
+    },
+    {
+      name: 'signal_stats',
+      description: 'Get signal statistics — counts by type, unprocessed total.',
+      auth: 'read',
+      schema: z.object({}),
+      handler: async () => {
+        return operatorProfile.signalStats();
+      },
+    },
+    {
+      name: 'synthesis_check',
+      description: 'Check if a synthesis pass is due based on signal/session thresholds.',
+      auth: 'read',
+      schema: z.object({}),
+      handler: async () => {
+        return operatorProfile.synthesisCheck();
+      },
+    },
+    {
+      name: 'profile_snapshot',
+      description: 'Create a versioned snapshot of the current profile.',
+      auth: 'write',
+      schema: z.object({
+        trigger: z.string().describe('What triggered this snapshot'),
+      }),
+      handler: async (params) => {
+        const snapshotted = operatorProfile.snapshot(params.trigger as string);
+        if (!snapshotted) return { snapshotted: false, reason: 'No profile exists' };
+        const profile = operatorProfile.getProfile();
+        return { snapshotted: true, version: profile?.version ?? 0 };
+      },
+    },
+  ];
+}

package/src/runtime/facades/orchestrate-facade.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Vault } from '../../vault/vault.js';
+import { Planner } from '../../planning/planner.js';
+import { Brain } from '../../brain/brain.js';
+import { BrainIntelligence } from '../../brain/intelligence.js';
+import { Governance } from '../../governance/governance.js';
+import { ProjectRegistry } from '../../project/project-registry.js';
+import { PlaybookExecutor } from '../../playbooks/playbook-executor.js';
+import { createOrchestrateFacadeOps } from './orchestrate-facade.js';
+import { captureOps, executeOp } from '../../engine/test-helpers.js';
+import type { CapturedOp } from '../../engine/test-helpers.js';
+import type { AgentRuntime } from '../types.js';
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeRuntime(vault: Vault): AgentRuntime {
+  const brain = new Brain(vault);
+  const plansPath = join(tmpdir(), `orch-test-${Date.now()}.json`);
+  const planner = new Planner(plansPath);
+  const brainIntelligence = new BrainIntelligence(vault, brain);
+  const governance = new Governance(vault);
+  const projectRegistry = new ProjectRegistry(vault.getProvider());
+  const playbookExecutor = new PlaybookExecutor();
+  const contextHealth = {
+    track: vi.fn(),
+    check: vi.fn().mockReturnValue({ level: 'green', estimatedFill: 0.1, toolCallCount: 5, estimatedTokens: 1000, recommendation: '' }),
+  };
+
+  return {
+    vault,
+    planner,
+    brain,
+    brainIntelligence,
+    governance,
+    projectRegistry,
+    playbookExecutor,
+    contextHealth,
+    config: { agentId: 'test-agent' },
+  } as unknown as AgentRuntime;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe('orchestrate-facade', () => {
+  let vault: Vault;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+    ops = captureOps(createOrchestrateFacadeOps(makeRuntime(vault)));
+  });
+
+  afterEach(() => {
+    vault.close();
+  });
+
+  it('registers session_start + satellite ops', () => {
+    expect(ops.size).toBeGreaterThanOrEqual(20);
+    expect([...ops.keys()]).toContain('session_start');
+    expect([...ops.keys()]).toContain('orchestrate_plan');
+    expect([...ops.keys()]).toContain('orchestrate_execute');
+    expect([...ops.keys()]).toContain('orchestrate_complete');
+    expect([...ops.keys()]).toContain('orchestrate_status');
+    expect([...ops.keys()]).toContain('orchestrate_quick_capture');
+    expect([...ops.keys()]).toContain('project_get');
+    expect([...ops.keys()]).toContain('project_list');
+    expect([...ops.keys()]).toContain('playbook_list');
+  });
+
+  it('has correct auth levels', () => {
+    expect(ops.get('session_start')!.auth).toBe('write');
+    expect(ops.get('orchestrate_plan')!.auth).toBe('write');
+    expect(ops.get('orchestrate_status')!.auth).toBe('read');
+    expect(ops.get('project_get')!.auth).toBe('read');
+    expect(ops.get('project_list')!.auth).toBe('read');
+  });
+
+  // ─── session_start ─────────────────────────────────────────────
+
+  it('session_start registers project and returns stats', async () => {
+    const result = await executeOp(ops, 'session_start', { projectPath: '/test/proj' });
+    expect(result.success).toBe(true);
+    const data = result.data as Record<string, unknown>;
+    expect(data.project).toBeDefined();
+    expect(data.is_new).toBe(true);
+    expect(data.vault).toBeDefined();
+    expect(data.governance).toBeDefined();
+  });
+
+  it('session_start increments session count on second call', async () => {
+    await executeOp(ops, 'session_start', { projectPath: '/test/proj' });
+    const result = await executeOp(ops, 'session_start', { projectPath: '/test/proj' });
+    expect(result.success).toBe(true);
+    const data = result.data as Record<string, unknown>;
+    expect(data.is_new).toBe(false);
+    expect(data.message).toContain('Session #2');
+  });
+
+  // ─── project_get ───────────────────────────────────────────────
+
+  it('project_get returns not found for unregistered project', async () => {
+    const result = await executeOp(ops, 'project_get', { projectId: 'nonexistent' });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).found).toBe(false);
+  });
+
+  // ─── project_list ──────────────────────────────────────────────
+
+  it('project_list returns empty initially', async () => {
+    const result = await executeOp(ops, 'project_list', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).count).toBe(0);
+  });
+
+  it('project_list includes registered projects', async () => {
+    await executeOp(ops, 'session_start', { projectPath: '/test/proj' });
+    const result = await executeOp(ops, 'project_list', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).count).toBeGreaterThanOrEqual(1);
+  });
+
+  // ─── orchestrate_status ────────────────────────────────────────
+
+  it('orchestrate_status returns combined status', async () => {
+    const result = await executeOp(ops, 'orchestrate_status', {});
+    expect(result.success).toBe(true);
+    const data = result.data as Record<string, unknown>;
+    expect(data.activePlans).toBeDefined();
+    expect(data.vaultStats).toBeDefined();
+    expect(data.brainStats).toBeDefined();
+  });
+
+  // ─── orchestrate_quick_capture ─────────────────────────────────
+
+  it('orchestrate_quick_capture captures knowledge', async () => {
+    const result = await executeOp(ops, 'orchestrate_quick_capture', {
+      domain: 'testing',
+      context: 'Learned that tests should be colocated',
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as Record<string, unknown>;
+    expect(data.session).toBeDefined();
+  });
+
+  // ─── playbook_list ─────────────────────────────────────────────
+
+  it('playbook_list returns empty with no playbooks', async () => {
+    const result = await executeOp(ops, 'playbook_list', {});
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).count).toBe(0);
+  });
+
+  // ─── project_add_rule ──────────────────────────────────────────
+
+  it('project_add_rule adds a rule to a project', async () => {
+    await executeOp(ops, 'session_start', { projectPath: '/test/proj' });
+    const listResult = await executeOp(ops, 'project_list', {});
+    const projects = (listResult.data as { projects: Array<Record<string, unknown>> }).projects;
+    const projectId = projects[0].id as string;
+
+    const result = await executeOp(ops, 'project_add_rule', {
+      projectId,
+      category: 'convention',
+      text: 'Use semantic tokens',
+      priority: 5,
+    });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).added).toBe(true);
+  });
+
+  // ─── project_unregister ────────────────────────────────────────
+
+  it('project_unregister removes a project', async () => {
+    await executeOp(ops, 'session_start', { projectPath: '/test/proj' });
+    const listResult = await executeOp(ops, 'project_list', {});
+    const projects = (listResult.data as { projects: Array<Record<string, unknown>> }).projects;
+    const projectId = projects[0].id as string;
+
+    const result = await executeOp(ops, 'project_unregister', { projectId });
+    expect(result.success).toBe(true);
+    expect((result.data as Record<string, unknown>).removed).toBe(true);
+  });
+});

package/src/runtime/facades/orchestrate-facade.ts

@@ -14,11 +14,11 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
   const { vault, governance, projectRegistry } = runtime;
 
   return [
-    // ─── Register (inline from core-ops.ts) ─────────────────────
+    // ─── Session Start (inline from core-ops.ts) ─────────────────────
     {
-      name: 'register',
+      name: 'session_start',
       description:
-        'Register a project for this session. Call on every new session to track usage and get context.',
+        'Start a session for this project. Call on every new session to track usage and get context.',
       auth: 'write',
       schema: z.object({
         projectPath: z.string().optional().default('.'),