@soleri/core 2.9.0 → 2.11.0

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

@@ -0,0 +1,55 @@
+/**
+ * Context facade — entity extraction, knowledge retrieval, and context analysis.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../../facades/types.js';
+import type { AgentRuntime } from '../types.js';
+
+export function createContextFacadeOps(runtime: AgentRuntime): OpDefinition[] {
+  const { contextEngine } = runtime;
+
+  return [
+    {
+      name: 'context_extract_entities',
+      description:
+        'Extract named entities from a prompt — files, functions, domains, actions, technologies, patterns.',
+      auth: 'read',
+      schema: z.object({
+        prompt: z.string().describe('The user prompt to analyze.'),
+      }),
+      handler: async (params) => {
+        return contextEngine.extractEntities(params.prompt as string);
+      },
+    },
+    {
+      name: 'context_retrieve_knowledge',
+      description:
+        'Retrieve relevant knowledge from vault (FTS), Cognee (vector), and brain (recommendations). Returns scored and ranked items.',
+      auth: 'read',
+      schema: z.object({
+        prompt: z.string().describe('Query to search for.'),
+        domain: z.string().optional().describe('Filter by domain.'),
+      }),
+      handler: async (params) => {
+        return contextEngine.retrieveKnowledge(
+          params.prompt as string,
+          params.domain as string | undefined,
+        );
+      },
+    },
+    {
+      name: 'context_analyze',
+      description:
+        'Full context analysis — extract entities, retrieve knowledge, compute confidence, detect domains. Combines all signals into a single response.',
+      auth: 'read',
+      schema: z.object({
+        prompt: z.string().describe('The user prompt to analyze.'),
+        domain: z.string().optional().describe('Optional domain hint.'),
+      }),
+      handler: async (params) => {
+        return contextEngine.analyze(params.prompt as string, params.domain as string | undefined);
+      },
+    },
+  ];
+}

package/src/runtime/facades/index.ts

@@ -17,6 +17,9 @@ import { createLoopFacadeOps } from './loop-facade.js';
 import { createOrchestrateFacadeOps } from './orchestrate-facade.js';
 import { createControlFacadeOps } from './control-facade.js';
 import { createCogneeFacadeOps } from './cognee-facade.js';
+import { createContextFacadeOps } from './context-facade.js';
+import { createAgencyFacadeOps } from './agency-facade.js';
+import { createChatFacadeOps } from './chat-facade.js';
 
 export function createSemanticFacades(runtime: AgentRuntime, agentId: string): FacadeConfig[] {
   return [
@@ -57,7 +60,8 @@ export function createSemanticFacades(runtime: AgentRuntime, agentId: string): F
     },
     {
       name: `${agentId}_orchestrate`,
-      description: 'Execution orchestration — project registration, playbooks, plan/execute/complete.',
+      description:
+        'Execution orchestration — project registration, playbooks, plan/execute/complete.',
       ops: createOrchestrateFacadeOps(runtime),
     },
     {
@@ -70,5 +74,22 @@ export function createSemanticFacades(runtime: AgentRuntime, agentId: string): F
       description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
       ops: createCogneeFacadeOps(runtime),
     },
+    {
+      name: `${agentId}_context`,
+      description: 'Context analysis — entity extraction, knowledge retrieval, confidence scoring.',
+      ops: createContextFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_agency`,
+      description:
+        'Proactive intelligence — file watching, pattern surfacing, warnings, clarification.',
+      ops: createAgencyFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_chat`,
+      description:
+        'Chat transport — session management, response chunking, authentication for chat-based interfaces.',
+      ops: createChatFacadeOps(runtime),
+    },
   ];
 }

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

@@ -6,13 +6,16 @@
 import { z } from 'zod';
 import type { OpDefinition } from '../../facades/types.js';
 import type { IntelligenceEntry } from '../../intelligence/types.js';
+import type { VaultTier } from '../../vault/vault-types.js';
 import type { AgentRuntime } from '../types.js';
 import { createVaultExtraOps } from '../vault-extra-ops.js';
 import { createCaptureOps } from '../capture-ops.js';
 import { createIntakeOps } from '../intake-ops.js';
+import { createVaultSharingOps } from '../vault-sharing-ops.js';
+import { ObsidianSync } from '../../vault/obsidian-sync.js';
 
 export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, cognee, llmClient, syncManager, intakePipeline } = runtime;
+  const { vault, brain, intakePipeline, vaultManager } = runtime;
 
   return [
     // ─── Search / Vault (inline from core-ops.ts) ───────────────
@@ -215,9 +218,266 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Multi-vault ops ────────────────────────────────────────
+    {
+      name: 'vault_connect',
+      description:
+        'Connect an additional vault tier (project or team). Opens a separate SQLite database.',
+      auth: 'admin',
+      schema: z.object({
+        tier: z.enum(['project', 'team']).describe('Vault tier to connect'),
+        path: z.string().describe('Path to the SQLite database file'),
+      }),
+      handler: async (params) => {
+        const tier = params.tier as VaultTier;
+        const path = params.path as string;
+        vaultManager.open(tier, path);
+        return { connected: true, tier, path };
+      },
+    },
+    {
+      name: 'vault_disconnect',
+      description: 'Disconnect a vault tier. Cannot disconnect the agent tier.',
+      auth: 'admin',
+      schema: z.object({
+        tier: z.enum(['project', 'team']).describe('Vault tier to disconnect'),
+      }),
+      handler: async (params) => {
+        const tier = params.tier as VaultTier;
+        const removed = vaultManager.disconnect(tier);
+        return { disconnected: removed, tier };
+      },
+    },
+    {
+      name: 'vault_tiers',
+      description: 'List all vault tiers with connection status and entry counts.',
+      auth: 'read',
+      handler: async () => {
+        return { tiers: vaultManager.listTiers() };
+      },
+    },
+    {
+      name: 'vault_search_all',
+      description:
+        'Search across all connected vault tiers with priority-weighted cascading. Agent tier results ranked highest.',
+      auth: 'read',
+      schema: z.object({
+        query: z.string(),
+        limit: z.number().optional(),
+      }),
+      handler: async (params) => {
+        const results = vaultManager.search(params.query as string, (params.limit as number) ?? 20);
+        return { results, count: results.length };
+      },
+    },
+
+    // ─── Named vault connections ────────────────────────────────
+    {
+      name: 'vault_connect_source',
+      description:
+        'Connect a named vault source (e.g., shared team knowledge base) with a configurable search priority.',
+      auth: 'admin',
+      schema: z.object({
+        name: z.string().describe('Unique name for this vault connection'),
+        path: z.string().describe('Path to the SQLite database file'),
+        priority: z
+          .number()
+          .min(0)
+          .max(2)
+          .optional()
+          .describe('Search priority weight (default: 0.5)'),
+      }),
+      handler: async (params) => {
+        const name = params.name as string;
+        const path = params.path as string;
+        const priority = (params.priority as number) ?? 0.5;
+        vaultManager.connect(name, path, priority);
+        return { connected: true, name, path, priority };
+      },
+    },
+    {
+      name: 'vault_disconnect_source',
+      description: 'Disconnect a named vault source.',
+      auth: 'admin',
+      schema: z.object({
+        name: z.string().describe('Name of the vault connection to remove'),
+      }),
+      handler: async (params) => {
+        const name = params.name as string;
+        const removed = vaultManager.disconnectNamed(name);
+        return { disconnected: removed, name };
+      },
+    },
+    {
+      name: 'vault_list_sources',
+      description: 'List all dynamically connected vault sources with their priorities.',
+      auth: 'read',
+      handler: async () => {
+        return { sources: vaultManager.listConnected() };
+      },
+    },
+
+    // ─── Branching ─────────────────────────────────────────────
+    {
+      name: 'vault_branch',
+      description:
+        'Create a named vault branch for experimentation. Changes can be reviewed and merged later.',
+      auth: 'write',
+      schema: z.object({
+        name: z.string().describe('Unique branch name'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        try {
+          vaultBranching.branch(params.name as string);
+          return { created: true, name: params.name };
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+    {
+      name: 'vault_branch_add',
+      description: 'Add an operation (add/modify/remove) to a vault branch.',
+      auth: 'write',
+      schema: z.object({
+        branchName: z.string().describe('Branch to add the operation to'),
+        entryId: z.string().describe('Entry ID'),
+        action: z.enum(['add', 'modify', 'remove']).describe('Operation type'),
+        entryData: z
+          .record(z.unknown())
+          .optional()
+          .describe('Full entry data (required for add/modify)'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        try {
+          vaultBranching.addOperation(
+            params.branchName as string,
+            params.entryId as string,
+            params.action as 'add' | 'modify' | 'remove',
+            params.entryData as IntelligenceEntry | undefined,
+          );
+          return {
+            added: true,
+            branchName: params.branchName,
+            entryId: params.entryId,
+            action: params.action,
+          };
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+    {
+      name: 'vault_branch_list',
+      description: 'List all vault branches with entry counts and merge status.',
+      auth: 'read',
+      handler: async () => {
+        const { vaultBranching } = runtime;
+        return { branches: vaultBranching.listBranches() };
+      },
+    },
+    {
+      name: 'vault_merge_branch',
+      description: 'Merge a branch into the main vault. Branch entries win on conflict.',
+      auth: 'admin',
+      schema: z.object({
+        branchName: z.string().describe('Branch to merge'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        try {
+          return vaultBranching.merge(params.branchName as string);
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+    {
+      name: 'vault_delete_branch',
+      description: 'Delete a vault branch and all its operations.',
+      auth: 'admin',
+      schema: z.object({
+        branchName: z.string().describe('Branch to delete'),
+      }),
+      handler: async (params) => {
+        const { vaultBranching } = runtime;
+        const deleted = vaultBranching.deleteBranch(params.branchName as string);
+        return { deleted, branchName: params.branchName };
+      },
+    },
+
+    // ─── Obsidian Sync ──────────────────────────────────────────
+    {
+      name: 'obsidian_export',
+      description:
+        'Export vault entries to Obsidian-compatible markdown files with YAML frontmatter. Creates domain subdirectories.',
+      auth: 'read',
+      schema: z.object({
+        obsidianDir: z.string().describe('Path to Obsidian vault directory'),
+        types: z.array(z.string()).optional().describe('Filter by entry types'),
+        domains: z.array(z.string()).optional().describe('Filter by domains'),
+        dryRun: z.boolean().optional().describe('Preview without writing files'),
+      }),
+      handler: async (params) => {
+        const sync = new ObsidianSync({ vault });
+        return sync.export(params.obsidianDir as string, {
+          types: params.types as string[] | undefined,
+          domains: params.domains as string[] | undefined,
+          dryRun: params.dryRun as boolean | undefined,
+        });
+      },
+    },
+    {
+      name: 'obsidian_import',
+      description:
+        'Import Obsidian markdown files with YAML frontmatter into the vault. Parses title, type, domain, tags from frontmatter.',
+      auth: 'write',
+      schema: z.object({
+        obsidianDir: z.string().describe('Path to Obsidian vault directory to import from'),
+        defaultType: z
+          .string()
+          .optional()
+          .describe('Default type for entries without frontmatter type'),
+        defaultDomain: z.string().optional().describe('Default domain for entries without one'),
+        dryRun: z.boolean().optional().describe('Preview without modifying vault'),
+      }),
+      handler: async (params) => {
+        const sync = new ObsidianSync({ vault });
+        return sync.import(params.obsidianDir as string, {
+          defaultType: params.defaultType as string | undefined,
+          defaultDomain: params.defaultDomain as string | undefined,
+          dryRun: params.dryRun as boolean | undefined,
+        });
+      },
+    },
+    {
+      name: 'obsidian_sync',
+      description:
+        'Bidirectional sync between vault and Obsidian directory. Modes: push (vault→Obsidian), pull (Obsidian→vault), bidirectional.',
+      auth: 'write',
+      schema: z.object({
+        obsidianDir: z.string().describe('Path to Obsidian vault directory'),
+        mode: z
+          .enum(['push', 'pull', 'bidirectional'])
+          .optional()
+          .describe('Sync mode. Default: bidirectional'),
+        dryRun: z.boolean().optional().describe('Preview without making changes'),
+      }),
+      handler: async (params) => {
+        const sync = new ObsidianSync({ vault });
+        return sync.sync(params.obsidianDir as string, {
+          mode: params.mode as 'push' | 'pull' | 'bidirectional' | undefined,
+          dryRun: params.dryRun as boolean | undefined,
+        });
+      },
+    },
+
     // ─── Satellite ops ───────────────────────────────────────────
     ...createVaultExtraOps(runtime),
     ...createCaptureOps(runtime),
     ...createIntakeOps(intakePipeline),
+    ...createVaultSharingOps(runtime),
   ];
 }

package/src/runtime/feature-flags.ts

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export interface FlagDefinition {
+  description: string;
+  defaultValue: boolean;
+}
+
+/** Built-in flags with defaults */
+const BUILT_IN_FLAGS: Record<string, FlagDefinition> = {
+  'auth-enforcement': {
+    description: 'Enforce auth levels in facade dispatch',
+    defaultValue: false,
+  },
+  'hot-reload': { description: 'Enable hot reload of vault and config', defaultValue: true },
+  'search-feedback': {
+    description: 'Record search feedback for brain learning',
+    defaultValue: true,
+  },
+  telemetry: { description: 'Collect op-level telemetry metrics', defaultValue: true },
+  'agency-mode': { description: 'Enable proactive agent behavior', defaultValue: false },
+  'cognee-sync': {
+    description: 'Sync vault entries to Cognee knowledge graph',
+    defaultValue: true,
+  },
+};
+
+export class FeatureFlags {
+  private flags: Map<string, boolean> = new Map();
+  private readonly filePath: string | null;
+
+  constructor(filePath?: string) {
+    this.filePath = filePath ?? null;
+
+    // 1. Apply defaults
+    for (const [name, def] of Object.entries(BUILT_IN_FLAGS)) {
+      this.flags.set(name, def.defaultValue);
+    }
+
+    // 2. Load from file (if exists)
+    if (this.filePath && existsSync(this.filePath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+        for (const [key, value] of Object.entries(data)) {
+          if (typeof value === 'boolean') {
+            this.flags.set(key, value);
+          }
+        }
+      } catch {
+        // Corrupt file — use defaults
+      }
+    }
+
+    // 3. Environment variable overrides: SOLERI_FLAG_AUTH_ENFORCEMENT=true
+    for (const [key, value] of Object.entries(process.env)) {
+      if (key.startsWith('SOLERI_FLAG_')) {
+        const flagName = key.slice('SOLERI_FLAG_'.length).toLowerCase().replace(/_/g, '-');
+        this.flags.set(flagName, value === 'true' || value === '1');
+      }
+    }
+  }
+
+  isEnabled(flag: string): boolean {
+    return this.flags.get(flag) ?? false;
+  }
+
+  set(flag: string, enabled: boolean): void {
+    this.flags.set(flag, enabled);
+    this.persist();
+  }
+
+  getAll(): Record<string, { enabled: boolean; description: string; source: string }> {
+    const result: Record<string, { enabled: boolean; description: string; source: string }> = {};
+    for (const [name, enabled] of this.flags) {
+      const builtIn = BUILT_IN_FLAGS[name];
+      const envKey = `SOLERI_FLAG_${name.replace(/-/g, '_').toUpperCase()}`;
+      const hasEnv = process.env[envKey] !== undefined;
+      result[name] = {
+        enabled,
+        description: builtIn?.description ?? 'Custom flag',
+        source: hasEnv ? 'env' : builtIn ? 'default' : 'runtime',
+      };
+    }
+    return result;
+  }
+
+  private persist(): void {
+    if (!this.filePath) return;
+    try {
+      const dir = dirname(this.filePath);
+      mkdirSync(dir, { recursive: true });
+      const obj: Record<string, boolean> = {};
+      for (const [k, v] of this.flags) {
+        obj[k] = v;
+      }
+      writeFileSync(this.filePath, JSON.stringify(obj, null, 2) + '\n');
+    } catch {
+      // Non-critical — flags still work in-memory
+    }
+  }
+}

package/src/runtime/pack-ops.ts

@@ -0,0 +1,85 @@
+/**
+ * Pack Operations — 4 ops for knowledge pack management.
+ *
+ * pack_install, pack_list, pack_uninstall, pack_validate
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+
+export function createPackOps(runtime: AgentRuntime): OpDefinition[] {
+  const { packInstaller } = runtime;
+
+  return [
+    // ─── pack_validate ────────────────────────────────────────────────
+    {
+      name: 'pack_validate',
+      description:
+        'Validate a knowledge pack directory without installing. Returns manifest, counts, and any errors/warnings.',
+      auth: 'read',
+      schema: z.object({
+        packDir: z.string().describe('Path to the knowledge pack directory.'),
+      }),
+      handler: async (params) => {
+        return packInstaller.validate(params.packDir as string);
+      },
+    },
+
+    // ─── pack_install ─────────────────────────────────────────────────
+    {
+      name: 'pack_install',
+      description:
+        'Install a knowledge pack — validates manifest, seeds vault entries, registers facades, discovers skills and hooks.',
+      auth: 'admin',
+      schema: z.object({
+        packDir: z.string().describe('Path to the knowledge pack directory.'),
+      }),
+      handler: async (params) => {
+        return packInstaller.install(params.packDir as string, runtime);
+      },
+    },
+
+    // ─── pack_list ────────────────────────────────────────────────────
+    {
+      name: 'pack_list',
+      description: 'List all installed knowledge packs with their status and contents.',
+      auth: 'read',
+      handler: async () => {
+        const packs = packInstaller.list();
+        return {
+          packs: packs.map((p) => ({
+            id: p.id,
+            name: p.manifest.name,
+            version: p.manifest.version,
+            domains: p.manifest.domains,
+            status: p.status,
+            vaultEntries: p.vaultEntries,
+            skills: p.skills,
+            hooks: p.hooks,
+            facadesRegistered: p.facadesRegistered,
+            error: p.error,
+          })),
+          count: packs.length,
+        };
+      },
+    },
+
+    // ─── pack_uninstall ───────────────────────────────────────────────
+    {
+      name: 'pack_uninstall',
+      description:
+        'Uninstall a knowledge pack — deactivates facades. Vault entries are NOT removed (knowledge persists).',
+      auth: 'admin',
+      schema: z.object({
+        packId: z.string().describe('Pack ID to uninstall.'),
+      }),
+      handler: async (params) => {
+        const packId = params.packId as string;
+        const success = packInstaller.uninstall(packId);
+        if (!success) return { error: `Pack not found: ${packId}` };
+        return { uninstalled: true, id: packId };
+      },
+    },
+  ];
+}