@soleri/core 2.1.0 → 2.5.0

package/src/runtime/playbook-ops.ts

@@ -0,0 +1,169 @@
+/**
+ * Playbook Operations — 5 ops for playbook management.
+ *
+ * Existing ops (moved from core-ops.ts):
+ *   playbook_list, playbook_get, playbook_create
+ *
+ * New ops:
+ *   playbook_match  — match playbooks by intent + text
+ *   playbook_seed   — seed built-in playbooks into vault
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+import { parsePlaybookFromEntry, validatePlaybook } from '../vault/playbook.js';
+import {
+  matchPlaybooks,
+  seedDefaultPlaybooks,
+  entryToPlaybookDefinition,
+} from '../playbooks/index.js';
+import type { PlaybookIntent } from '../playbooks/index.js';
+
+export function createPlaybookOps(runtime: AgentRuntime): OpDefinition[] {
+  const { vault } = runtime;
+
+  return [
+    // ─── playbook_list ──────────────────────────────────────────────
+    {
+      name: 'playbook_list',
+      description: 'List playbooks stored in the vault, optionally filtered by domain.',
+      auth: 'read',
+      schema: z.object({
+        domain: z.string().optional(),
+        limit: z.number().optional(),
+      }),
+      handler: async (params) => {
+        const entries = vault.list({
+          type: 'playbook',
+          domain: params.domain as string | undefined,
+          limit: (params.limit as number) ?? 50,
+        });
+        const playbooks = entries.map((e) => parsePlaybookFromEntry(e)).filter((p) => p !== null);
+        return { playbooks, count: playbooks.length };
+      },
+    },
+
+    // ─── playbook_get ───────────────────────────────────────────────
+    {
+      name: 'playbook_get',
+      description: 'Get a single playbook by ID, parsed into structured steps.',
+      auth: 'read',
+      schema: z.object({ id: z.string() }),
+      handler: async (params) => {
+        const entry = vault.get(params.id as string);
+        if (!entry) return { error: 'Playbook not found: ' + params.id };
+        if (entry.type !== 'playbook') return { error: 'Entry is not a playbook: ' + params.id };
+        const playbook = parsePlaybookFromEntry(entry);
+        if (!playbook) return { error: 'Failed to parse playbook context: ' + params.id };
+        return playbook;
+      },
+    },
+
+    // ─── playbook_create ────────────────────────────────────────────
+    {
+      name: 'playbook_create',
+      description:
+        'Create a playbook with structured steps. Validates step ordering and builds vault entry automatically.',
+      auth: 'write',
+      schema: z.object({
+        id: z.string().optional(),
+        title: z.string(),
+        domain: z.string(),
+        description: z.string(),
+        steps: z.array(
+          z.object({
+            title: z.string(),
+            description: z.string(),
+            validation: z.string().optional(),
+          }),
+        ),
+        tags: z.array(z.string()).optional().default([]),
+        severity: z.enum(['critical', 'warning', 'suggestion']).optional().default('suggestion'),
+      }),
+      handler: async (params) => {
+        const title = params.title as string;
+        const domain = params.domain as string;
+        const rawSteps = params.steps as Array<{
+          title: string;
+          description: string;
+          validation?: string;
+        }>;
+
+        const steps = rawSteps.map((s, i) => ({ ...s, order: i + 1 }));
+        const id =
+          (params.id as string | undefined) ??
+          `playbook-${domain}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+        const playbook = {
+          id,
+          title,
+          domain,
+          description: params.description as string,
+          steps,
+          tags: params.tags as string[],
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        };
+
+        const validation = validatePlaybook(playbook);
+        if (!validation.valid) {
+          return { created: false, id, errors: validation.errors };
+        }
+
+        vault.add({
+          id,
+          type: 'playbook',
+          domain,
+          title,
+          severity:
+            (params.severity as 'critical' | 'warning' | 'suggestion' | undefined) ?? 'suggestion',
+          description: params.description as string,
+          context: JSON.stringify({ steps }),
+          tags: params.tags as string[],
+        });
+
+        return { created: true, id, steps: steps.length };
+      },
+    },
+
+    // ─── playbook_match (NEW) ───────────────────────────────────────
+    {
+      name: 'playbook_match',
+      description:
+        'Match playbooks by intent and text. Combines vault-stored and built-in playbooks, returns best match with merged gates/tasks/tools.',
+      auth: 'read',
+      schema: z.object({
+        intent: z
+          .enum(['BUILD', 'FIX', 'REVIEW', 'PLAN', 'IMPROVE', 'DELIVER'])
+          .optional()
+          .describe('Plan intent for matching'),
+        text: z.string().describe('Plan objective + scope text to match against'),
+      }),
+      handler: async (params) => {
+        const intent = params.intent as PlaybookIntent | undefined;
+        const text = params.text as string;
+
+        // Load vault playbooks and convert to PlaybookDefinition
+        const vaultEntries = vault.list({ type: 'playbook', limit: 200 });
+        const vaultPlaybooks = vaultEntries
+          .map((e) => entryToPlaybookDefinition(e))
+          .filter((p): p is NonNullable<typeof p> => p !== null);
+
+        const result = matchPlaybooks(intent, text, vaultPlaybooks);
+        return result;
+      },
+    },
+
+    // ─── playbook_seed (NEW) ────────────────────────────────────────
+    {
+      name: 'playbook_seed',
+      description:
+        'Seed built-in playbooks into the vault. Idempotent — skips existing playbooks. Seeds 6 generic playbooks (TDD, brainstorming, code-review, subagent-execution, debugging, verification).',
+      auth: 'write',
+      handler: async () => {
+        return seedDefaultPlaybooks(vault);
+      },
+    },
+  ];
+}

package/src/runtime/project-ops.ts

@@ -0,0 +1,202 @@
+/**
+ * Project registry operations — 12 ops for managing projects, rules, and links.
+ *
+ * These ops expose the ProjectRegistry module as facade operations.
+ * All state is persisted in the Vault's SQLite database.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+
+/**
+ * Create the 12 project registry operations for an agent runtime.
+ *
+ * Groups: projects (3), rules (4), links (4), misc (1).
+ */
+export function createProjectOps(runtime: AgentRuntime): OpDefinition[] {
+  const { projectRegistry } = runtime;
+
+  return [
+    // ─── Projects ───────────────────────────────────────────────────
+    {
+      name: 'project_get',
+      description: 'Get a registered project by ID.',
+      auth: 'read',
+      schema: z.object({
+        projectId: z.string().describe('Project ID to look up'),
+      }),
+      handler: async (params) => {
+        const project = projectRegistry.get(params.projectId as string);
+        if (!project) {
+          return { found: false, project: null };
+        }
+        return { found: true, project };
+      },
+    },
+    {
+      name: 'project_list',
+      description: 'List all registered projects, ordered by last accessed time.',
+      auth: 'read',
+      handler: async () => {
+        const projects = projectRegistry.list();
+        return { count: projects.length, projects };
+      },
+    },
+    {
+      name: 'project_unregister',
+      description: 'Unregister a project — removes it and all associated rules and links.',
+      auth: 'write',
+      schema: z.object({
+        projectId: z.string().describe('Project ID to unregister'),
+      }),
+      handler: async (params) => {
+        const removed = projectRegistry.unregister(params.projectId as string);
+        return { removed, projectId: params.projectId };
+      },
+    },
+
+    // ─── Rules ──────────────────────────────────────────────────────
+    {
+      name: 'project_get_rules',
+      description: 'Get all rules for a specific project.',
+      auth: 'read',
+      schema: z.object({
+        projectId: z.string().describe('Project ID'),
+      }),
+      handler: async (params) => {
+        const rules = projectRegistry.getRules(params.projectId as string);
+        return { count: rules.length, rules };
+      },
+    },
+    {
+      name: 'project_list_rules',
+      description: 'List all projects with their associated rules.',
+      auth: 'read',
+      handler: async () => {
+        const result = projectRegistry.listRulesAll();
+        return {
+          count: result.length,
+          projects: result.map((r) => ({
+            project: r.project,
+            ruleCount: r.rules.length,
+            rules: r.rules,
+          })),
+        };
+      },
+    },
+    {
+      name: 'project_add_rule',
+      description: 'Add a rule to a project — behavior, preference, restriction, or convention.',
+      auth: 'write',
+      schema: z.object({
+        projectId: z.string().describe('Project ID to add the rule to'),
+        category: z
+          .enum(['behavior', 'preference', 'restriction', 'convention'])
+          .describe('Rule category'),
+        text: z.string().describe('Rule text'),
+        priority: z.number().default(0).describe('Priority (higher = more important)'),
+      }),
+      handler: async (params) => {
+        const rule = projectRegistry.addRule(params.projectId as string, {
+          category: params.category as 'behavior' | 'preference' | 'restriction' | 'convention',
+          text: params.text as string,
+          priority: (params.priority as number) ?? 0,
+        });
+        return { added: true, rule };
+      },
+    },
+    {
+      name: 'project_remove_rule',
+      description: 'Remove a project rule by its ID.',
+      auth: 'write',
+      schema: z.object({
+        ruleId: z.string().describe('Rule ID to remove'),
+      }),
+      handler: async (params) => {
+        const removed = projectRegistry.removeRule(params.ruleId as string);
+        return { removed, ruleId: params.ruleId };
+      },
+    },
+
+    // ─── Links ──────────────────────────────────────────────────────
+    {
+      name: 'project_link',
+      description: 'Create a link between two projects (related, parent, child, fork).',
+      auth: 'write',
+      schema: z.object({
+        sourceId: z.string().describe('Source project ID'),
+        targetId: z.string().describe('Target project ID'),
+        linkType: z.enum(['related', 'parent', 'child', 'fork']).describe('Type of link'),
+      }),
+      handler: async (params) => {
+        const link = projectRegistry.link(
+          params.sourceId as string,
+          params.targetId as string,
+          params.linkType as 'related' | 'parent' | 'child' | 'fork',
+        );
+        return { linked: true, link };
+      },
+    },
+    {
+      name: 'project_unlink',
+      description: 'Remove links between two projects. Omit linkType to remove all link types.',
+      auth: 'write',
+      schema: z.object({
+        sourceId: z.string().describe('Source project ID'),
+        targetId: z.string().describe('Target project ID'),
+        linkType: z
+          .enum(['related', 'parent', 'child', 'fork'])
+          .optional()
+          .describe('Specific link type to remove'),
+      }),
+      handler: async (params) => {
+        const count = projectRegistry.unlink(
+          params.sourceId as string,
+          params.targetId as string,
+          params.linkType as 'related' | 'parent' | 'child' | 'fork' | undefined,
+        );
+        return { removed: count, sourceId: params.sourceId, targetId: params.targetId };
+      },
+    },
+    {
+      name: 'project_get_links',
+      description: 'Get all links for a project (both incoming and outgoing).',
+      auth: 'read',
+      schema: z.object({
+        projectId: z.string().describe('Project ID'),
+      }),
+      handler: async (params) => {
+        const links = projectRegistry.getLinks(params.projectId as string);
+        return { count: links.length, links };
+      },
+    },
+    {
+      name: 'project_linked_projects',
+      description:
+        'Get linked projects with full details — project info, link type, and direction.',
+      auth: 'read',
+      schema: z.object({
+        projectId: z.string().describe('Project ID'),
+      }),
+      handler: async (params) => {
+        const linked = projectRegistry.getLinkedProjects(params.projectId as string);
+        return { count: linked.length, linked };
+      },
+    },
+
+    // ─── Misc ───────────────────────────────────────────────────────
+    {
+      name: 'project_touch',
+      description: 'Update the last accessed timestamp for a project.',
+      auth: 'write',
+      schema: z.object({
+        projectId: z.string().describe('Project ID to touch'),
+      }),
+      handler: async (params) => {
+        projectRegistry.touch(params.projectId as string);
+        return { touched: true, projectId: params.projectId };
+      },
+    },
+  ];
+}

package/src/runtime/runtime.ts

@@ -14,9 +14,21 @@ import { Brain } from '../brain/brain.js';
 import { BrainIntelligence } from '../brain/intelligence.js';
 import { Planner } from '../planning/planner.js';
 import { Curator } from '../curator/curator.js';
+import { Governance } from '../governance/governance.js';
+import { CogneeClient } from '../cognee/client.js';
+import { LoopManager } from '../loop/loop-manager.js';
+import { IdentityManager } from '../control/identity-manager.js';
+import { IntentRouter } from '../control/intent-router.js';
 import { KeyPool, loadKeyPoolConfig } from '../llm/key-pool.js';
 import { loadIntelligenceData } from '../intelligence/loader.js';
 import { LLMClient } from '../llm/llm-client.js';
+import { CogneeSyncManager } from '../cognee/sync-manager.js';
+import { IntakePipeline } from '../intake/intake-pipeline.js';
+import { Telemetry } from '../telemetry/telemetry.js';
+import { ProjectRegistry } from '../project/project-registry.js';
+import { TemplateManager } from '../prompts/template-manager.js';
+import { existsSync } from 'node:fs';
+import { createLogger } from '../logging/logger.js';
 import type { AgentRuntimeConfig, AgentRuntime } from './types.js';
 
 /**
@@ -33,6 +45,9 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const vaultPath = config.vaultPath ?? join(agentHome, 'vault.db');
   const plansPath = config.plansPath ?? join(agentHome, 'plans.json');
 
+  // Logger — structured output to stderr
+  const logger = createLogger({ level: config.logLevel, prefix: `[${agentId}]` });
+
   // Vault — persistent SQLite knowledge store
   const vault = new Vault(vaultPath);
 
@@ -47,14 +62,46 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   // Planner — multi-step task tracking
   const planner = new Planner(plansPath);
 
+  // Cognee — vector search client (graceful degradation if Cognee is down)
+  const cogneePartial: Partial<import('../cognee/types.js').CogneeConfig> = { dataset: agentId };
+  if (process.env.COGNEE_BASE_URL) cogneePartial.baseUrl = process.env.COGNEE_BASE_URL;
+  if (process.env.COGNEE_API_TOKEN) cogneePartial.apiToken = process.env.COGNEE_API_TOKEN;
+  if (process.env.COGNEE_DATASET) cogneePartial.dataset = process.env.COGNEE_DATASET;
+  const cognee = new CogneeClient(cogneePartial);
+
   // Brain — intelligence layer (TF-IDF scoring, auto-tagging, dedup)
-  const brain = new Brain(vault);
+  const brain = new Brain(vault, cognee);
 
   // Brain Intelligence — pattern strengths, session knowledge, intelligence pipeline
   const brainIntelligence = new BrainIntelligence(vault, brain);
 
   // Curator — vault self-maintenance (dedup, contradictions, grooming, health)
-  const curator = new Curator(vault);
+  const curator = new Curator(vault, cognee);
+
+  // Governance — policy engine + proposal tracker for gated knowledge capture
+  const governance = new Governance(vault);
+
+  // Loop Manager — iterative validation loop tracking (in-memory, session-scoped)
+  const loop = new LoopManager();
+
+  // Identity Manager — agent persona CRUD with versioning/rollback
+  const identityManager = new IdentityManager(vault);
+
+  // Intent Router — keyword-based intent classification and mode management
+  const intentRouter = new IntentRouter(vault);
+
+  // Telemetry — in-memory facade call tracking
+  const telemetry = new Telemetry();
+
+  // Project Registry — multi-project tracking with rules and links
+  const projectRegistry = new ProjectRegistry(vault.getDb());
+
+  // Template Manager — prompt templates with variable substitution
+  const templatesDir = config.templatesDir ?? join(agentHome, 'templates');
+  const templateManager = new TemplateManager(templatesDir);
+  if (existsSync(templatesDir)) {
+    templateManager.load();
+  }
 
   // LLM key pools and client
   const keyPoolFiles = loadKeyPoolConfig(agentId);
@@ -62,15 +109,42 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const anthropicKeyPool = new KeyPool(keyPoolFiles.anthropic);
   const llmClient = new LLMClient(openaiKeyPool, anthropicKeyPool, agentId);
 
+  // Cognee Sync Manager — queue-based dirty tracking with offline resilience
+  const syncManager = new CogneeSyncManager(
+    vault.getProvider(),
+    cognee,
+    cogneePartial.dataset ?? agentId,
+  );
+  vault.setSyncManager(syncManager);
+
+  // Intake Pipeline — PDF/book ingestion with LLM classification
+  const intakePipeline = new IntakePipeline(vault.getProvider(), vault, llmClient);
+
   return {
     config,
+    logger,
     vault,
     brain,
     brainIntelligence,
     planner,
     curator,
+    governance,
+    cognee,
+    loop,
+    identityManager,
+    intentRouter,
     keyPool: { openai: openaiKeyPool, anthropic: anthropicKeyPool },
     llmClient,
-    close: () => vault.close(),
+    telemetry,
+    projectRegistry,
+    templateManager,
+    syncManager,
+    intakePipeline,
+    createdAt: Date.now(),
+    close: () => {
+      syncManager.close();
+      cognee.resetPendingCognify();
+      vault.close();
+    },
   };
 }

package/src/runtime/types.ts

@@ -3,8 +3,20 @@ import type { Brain } from '../brain/brain.js';
 import type { BrainIntelligence } from '../brain/intelligence.js';
 import type { Planner } from '../planning/planner.js';
 import type { Curator } from '../curator/curator.js';
+import type { Governance } from '../governance/governance.js';
+import type { CogneeClient } from '../cognee/client.js';
 import type { KeyPool } from '../llm/key-pool.js';
 import type { LLMClient } from '../llm/llm-client.js';
+import type { IdentityManager } from '../control/identity-manager.js';
+import type { IntentRouter } from '../control/intent-router.js';
+import type { LoopManager } from '../loop/loop-manager.js';
+import type { Telemetry } from '../telemetry/telemetry.js';
+import type { ProjectRegistry } from '../project/project-registry.js';
+import type { TemplateManager } from '../prompts/template-manager.js';
+import type { CogneeSyncManager } from '../cognee/sync-manager.js';
+import type { IntakePipeline } from '../intake/intake-pipeline.js';
+import type { Logger } from '../logging/logger.js';
+import type { LogLevel } from '../logging/types.js';
 
 /**
  * Configuration for creating an agent runtime.
@@ -19,6 +31,10 @@ export interface AgentRuntimeConfig {
   plansPath?: string;
   /** Intelligence data directory to seed vault from. Optional. */
   dataDir?: string;
+  /** Path to prompt templates directory. Default: ~/.{agentId}/templates */
+  templatesDir?: string;
+  /** Minimum log level. Default: 'info' (or SOLERI_LOG_LEVEL env var). */
+  logLevel?: LogLevel;
 }
 
 /**
@@ -27,13 +43,26 @@ export interface AgentRuntimeConfig {
  */
 export interface AgentRuntime {
   config: AgentRuntimeConfig;
+  logger: Logger;
   vault: Vault;
   brain: Brain;
   brainIntelligence: BrainIntelligence;
   planner: Planner;
   curator: Curator;
+  governance: Governance;
+  cognee: CogneeClient;
+  loop: LoopManager;
+  identityManager: IdentityManager;
+  intentRouter: IntentRouter;
   keyPool: { openai: KeyPool; anthropic: KeyPool };
   llmClient: LLMClient;
+  telemetry: Telemetry;
+  projectRegistry: ProjectRegistry;
+  templateManager: TemplateManager;
+  syncManager: CogneeSyncManager;
+  intakePipeline: IntakePipeline;
+  /** Timestamp (ms since epoch) when this runtime was created. */
+  createdAt: number;
   /** Close the vault database connection. Call on shutdown. */
   close(): void;
 }