@soleri/core 2.12.0 → 8.0.0

package/src/runtime/runtime.ts

@@ -19,10 +19,12 @@ 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 { discoverAnthropicToken } from '../llm/oauth-discovery.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 { TextIngester } from '../intake/text-ingester.js';
 import { Telemetry } from '../telemetry/telemetry.js';
 import { ProjectRegistry } from '../project/project-registry.js';
 import { TemplateManager } from '../prompts/template-manager.js';
@@ -39,6 +41,14 @@ import { VaultBranching } from '../vault/vault-branching.js';
 import { ContextEngine } from '../context/context-engine.js';
 import { AgencyManager } from '../agency/agency-manager.js';
 import { KnowledgeReview } from '../vault/knowledge-review.js';
+import { LinkManager } from '../vault/linking.js';
+import { LearningRadar } from '../brain/learning-radar.js';
+import { KnowledgeSynthesizer } from '../brain/knowledge-synthesizer.js';
+import { ChainRunner } from '../flows/chain-runner.js';
+import { JobQueue } from '../queue/job-queue.js';
+import { PipelineRunner } from '../queue/pipeline-runner.js';
+import { evaluateQuality } from '../curator/quality-gate.js';
+import { classifyEntry } from '../curator/classifier.js';
 import type { AgentRuntimeConfig, AgentRuntime } from './types.js';
 
 /**
@@ -85,21 +95,25 @@ 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);
+  // Cognee — vector search client (opt-in, graceful degradation if Cognee is down)
+  let cognee: CogneeClient | null = null;
+  if (config.cognee) {
+    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;
+    cognee = new CogneeClient(cogneePartial);
+  }
 
   // Brain — intelligence layer (TF-IDF scoring, auto-tagging, dedup)
-  const brain = new Brain(vault, cognee);
+  // Pass vaultManager so intelligentSearch queries all connected sources (not just agent tier)
+  const brain = new Brain(vault, cognee ?? undefined, vaultManager);
 
   // 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, cognee);
+  const curator = new Curator(vault, cognee ?? undefined);
 
   // Governance — policy engine + proposal tracker for gated knowledge capture
   const governance = new Governance(vault);
@@ -127,21 +141,35 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   }
 
   // LLM key pools and client
+  // Try OAuth token discovery for Anthropic (Claude Code subscription → free API access)
   const keyPoolFiles = loadKeyPoolConfig(agentId);
+  const oauthToken = discoverAnthropicToken();
+  const anthropicConfig = keyPoolFiles.anthropic;
+  if (oauthToken && anthropicConfig.keys.length === 0) {
+    anthropicConfig.keys.push(oauthToken);
+  }
   const openaiKeyPool = new KeyPool(keyPoolFiles.openai);
-  const anthropicKeyPool = new KeyPool(keyPoolFiles.anthropic);
+  const anthropicKeyPool = new KeyPool(anthropicConfig);
   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);
+  // Cognee Sync Manager — queue-based dirty tracking with offline resilience (only when Cognee enabled)
+  let syncManager: CogneeSyncManager | null = null;
+  if (cognee) {
+    syncManager = new CogneeSyncManager(
+      vault.getProvider(),
+      cognee,
+      process.env.COGNEE_DATASET ?? agentId,
+    );
+    vault.setSyncManager(syncManager);
+  }
+
+  // Link Manager — Zettelkasten auto-linking on vault ingestion
+  const linkManager = new LinkManager(vault.getProvider());
+  vault.setLinkManager(linkManager, { enabled: true, maxLinks: 3 });
 
   // Intake Pipeline — PDF/book ingestion with LLM classification
   const intakePipeline = new IntakePipeline(vault.getProvider(), vault, llmClient);
+  const textIngester = new TextIngester(vault, llmClient);
 
   // Playbook Executor — in-memory step-by-step workflow sessions
   const playbookExecutor = new PlaybookExecutor();
@@ -168,7 +196,10 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const health = new HealthRegistry();
   health.register('vault', 'healthy');
   health.register('brain', 'healthy');
-  health.register('cognee', cognee.getStatus()?.available ? 'healthy' : 'degraded');
+  health.register(
+    'cognee',
+    cognee ? (cognee.getStatus()?.available ? 'healthy' : 'degraded') : 'down',
+  );
   health.register(
     'llm',
     llmClient.isAvailable().openai || llmClient.isAvailable().anthropic ? 'healthy' : 'degraded',
@@ -208,6 +239,7 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     templateManager,
     syncManager,
     intakePipeline,
+    textIngester,
     authPolicy: { mode: 'permissive', callerLevel: 'admin' },
     flags: new FeatureFlags(join(agentHome, 'flags.json')),
     health,
@@ -219,10 +251,123 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     contextEngine,
     agencyManager,
     knowledgeReview,
+    linkManager,
+    learningRadar: new LearningRadar(vault, brain),
+    knowledgeSynthesizer: new KnowledgeSynthesizer(brain, llmClient),
+    chainRunner: new ChainRunner(vault.getProvider()),
+    jobQueue: new JobQueue(vault.getProvider()),
+    pipelineRunner: (() => {
+      const jq = new JobQueue(vault.getProvider());
+      const pr = new PipelineRunner(jq);
+      // Register default job handlers for curator pipeline
+      pr.registerHandler('tag-normalize', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        const result = curator.normalizeTag(entry.tags[0] ?? '');
+        return result;
+      });
+      pr.registerHandler('dedup-check', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        return curator.detectDuplicates(entry.id);
+      });
+      pr.registerHandler('auto-link', async (job) => {
+        if (linkManager) {
+          const suggestions = linkManager.suggestLinks(job.entryId ?? '', 3);
+          for (const s of suggestions) {
+            linkManager.addLink(
+              job.entryId ?? '',
+              s.entryId,
+              s.suggestedType,
+              `pipeline: ${s.reason}`,
+            );
+          }
+          return { linked: suggestions.length };
+        }
+        return { skipped: true, reason: 'link manager not available' };
+      });
+      pr.registerHandler('quality-gate', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        return evaluateQuality(entry, llmClient);
+      });
+      pr.registerHandler('classify', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        return classifyEntry(entry, llmClient);
+      });
+
+      // ─── 9 additional handlers for full Salvador parity (#216) ────
+      pr.registerHandler('enrich-frontmatter', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        return curator.enrichMetadata(entry.id);
+      });
+      pr.registerHandler('detect-staleness', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        // Check if entry is older than 90 days (using validFrom or fallback to 0)
+        const entryTimestamp = (entry.validFrom ?? 0) * 1000 || Date.now();
+        const ageMs = Date.now() - entryTimestamp;
+        const staleDays = 90;
+        const isStale = ageMs > staleDays * 86400000;
+        return { stale: isStale, ageDays: Math.floor(ageMs / 86400000), entryId: entry.id };
+      });
+      pr.registerHandler('detect-duplicate', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        return curator.detectDuplicates(entry.id);
+      });
+      pr.registerHandler('detect-contradiction', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        const contradictions = curator.detectContradictions(0.4);
+        const relevant = contradictions.filter(
+          (c) => c.patternId === job.entryId || c.antipatternId === job.entryId,
+        );
+        return { found: relevant.length, contradictions: relevant };
+      });
+      pr.registerHandler('consolidate-duplicates', async (_job) => {
+        return curator.consolidate({ dryRun: false, staleDaysThreshold: 90 });
+      });
+      pr.registerHandler('archive-stale', async (_job) => {
+        // Run consolidation with stale detection
+        const result = curator.consolidate({ dryRun: false, staleDaysThreshold: 90 });
+        return { archived: result.staleEntries.length, result };
+      });
+      pr.registerHandler('cognee-ingest', async (job) => {
+        if (!cognee) return { skipped: true, reason: 'cognee not available' };
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        try {
+          const result = await cognee.addEntries([entry]);
+          return { ingested: result.added };
+        } catch {
+          return { skipped: true, reason: 'cognee ingestion failed' };
+        }
+      });
+      pr.registerHandler('cognee-cognify', async (_job) => {
+        if (!cognee) return { skipped: true, reason: 'cognee not available' };
+        try {
+          const result = await cognee.cognify();
+          return result;
+        } catch {
+          return { skipped: true, reason: 'cognee cognify failed' };
+        }
+      });
+      pr.registerHandler('verify-searchable', async (job) => {
+        const entry = vault.get(job.entryId ?? '');
+        if (!entry) return { skipped: true, reason: 'entry not found' };
+        const searchResults = vault.search(entry.title, { limit: 1 });
+        const found = searchResults.some((r) => r.entry.id === entry.id);
+        return { searchable: found, entryId: entry.id };
+      });
+      return pr;
+    })(),
     createdAt: Date.now(),
     close: () => {
-      syncManager.close();
-      cognee.resetPendingCognify();
+      syncManager?.close();
+      cognee?.resetPendingCognify();
       vaultManager.close();
     },
   };

package/src/runtime/session-briefing.ts

@@ -0,0 +1,161 @@
+/**
+ * Session Briefing — proactive context loading on session start.
+ *
+ * Gathers data from all subsystems (sessions, plans, vault, brain, curator)
+ * and produces a concise, structured briefing for the agent.
+ *
+ * Design: gather all data in parallel, skip sections with nothing to report.
+ * Target: < 15 lines of output, < 3 seconds latency.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+
+export interface BriefingSection {
+  label: string;
+  content: string;
+}
+
+export interface SessionBriefing {
+  sections: BriefingSection[];
+  generatedAt: number;
+  /** Total entries consulted across all data sources. */
+  dataPointsConsulted: number;
+}
+
+export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[] {
+  const { brainIntelligence, planner, vault, curator } = runtime;
+
+  return [
+    {
+      name: 'session_briefing',
+      description:
+        'Proactive session briefing — gathers last session, active plans, recent vault captures, brain recommendations, and stale knowledge warnings into a concise summary.',
+      auth: 'read',
+      schema: z.object({
+        maxSections: z.number().optional().default(6).describe('Max sections to include'),
+        recencyHours: z.number().optional().default(48).describe('Look back window in hours'),
+      }),
+      handler: async (params) => {
+        const maxSections = params.maxSections as number;
+        const sections: BriefingSection[] = [];
+        let dataPoints = 0;
+
+        // 1. Last session
+        try {
+          const sessions = brainIntelligence.listSessions({ limit: 1, active: false });
+          dataPoints += sessions.length;
+          if (sessions.length > 0) {
+            const last = sessions[0];
+            const ago = formatTimeAgo(last.endedAt ? new Date(last.endedAt).getTime() : Date.now());
+            const domain = last.domain ? ` [${last.domain}]` : '';
+            const context = last.context ? `: ${last.context.slice(0, 80)}` : '';
+            const tools = last.toolsUsed.length > 0 ? `, used ${last.toolsUsed.length} tools` : '';
+            const files =
+              last.filesModified.length > 0 ? `, modified ${last.filesModified.length} files` : '';
+            sections.push({
+              label: 'Last session',
+              content: `(${ago})${domain}${context}${tools}${files}`,
+            });
+          }
+        } catch {
+          // Session data unavailable — skip
+        }
+
+        // 2. Active plans
+        try {
+          const plans = planner.list();
+          const active = plans.filter(
+            (p) =>
+              p.status === 'executing' ||
+              p.status === 'approved' ||
+              p.status === 'reconciling' ||
+              p.status === 'validating',
+          );
+          dataPoints += plans.length;
+          if (active.length > 0) {
+            const summaries = active.map((p) => {
+              const tasksDone = p.tasks.filter((t) => t.status === 'completed').length;
+              return `${p.objective?.slice(0, 40) || p.id} (${p.status}, ${tasksDone}/${p.tasks.length} tasks)`;
+            });
+            sections.push({
+              label: active.length === 1 ? 'Active plan' : `Active plans (${active.length})`,
+              content: summaries.join('; '),
+            });
+          }
+        } catch {
+          // Planner unavailable — skip
+        }
+
+        // 3. Recent vault captures
+        try {
+          const recent = vault.getRecent(10);
+          dataPoints += recent.length;
+          if (recent.length > 0) {
+            const count = Math.min(recent.length, 5);
+            const titles = recent.slice(0, 3).map((e) => e.title.slice(0, 50));
+            sections.push({
+              label: 'Recent captures',
+              content: `${count} entries — ${titles.join(', ')}${count > 3 ? '...' : ''}`,
+            });
+          }
+        } catch {
+          // Vault unavailable — skip
+        }
+
+        // 4. Brain recommendations
+        try {
+          const recs = brainIntelligence.recommend({ limit: 3 });
+          dataPoints += recs.length;
+          if (recs.length > 0) {
+            const items = recs.map((r) => `"${r.pattern}" (strength: ${r.strength.toFixed(2)})`);
+            sections.push({
+              label: 'Brain recommends',
+              content: items.join(', '),
+            });
+          }
+        } catch {
+          // Brain unavailable — skip
+        }
+
+        // 5. Stale knowledge / health warnings
+        try {
+          const health = curator.healthAudit();
+          dataPoints += 1;
+          const warnings: string[] = [];
+          if (health.score < 70) {
+            warnings.push(`vault health: ${health.score}/100`);
+          }
+          if (health.recommendations && health.recommendations.length > 0) {
+            warnings.push(health.recommendations[0]);
+          }
+          if (warnings.length > 0) {
+            sections.push({
+              label: 'Attention',
+              content: warnings.join('. '),
+            });
+          }
+        } catch {
+          // Curator unavailable — skip
+        }
+
+        return {
+          sections: sections.slice(0, maxSections),
+          generatedAt: Date.now(),
+          dataPointsConsulted: dataPoints,
+        } satisfies SessionBriefing;
+      },
+    },
+  ];
+}
+
+function formatTimeAgo(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  const minutes = Math.floor(diff / 60000);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}

package/src/runtime/types.ts

@@ -28,6 +28,13 @@ import type { VaultBranching } from '../vault/vault-branching.js';
 import type { ContextEngine } from '../context/context-engine.js';
 import type { AgencyManager } from '../agency/agency-manager.js';
 import type { KnowledgeReview } from '../vault/knowledge-review.js';
+import type { LinkManager } from '../vault/linking.js';
+import type { LearningRadar } from '../brain/learning-radar.js';
+import type { TextIngester } from '../intake/text-ingester.js';
+import type { KnowledgeSynthesizer } from '../brain/knowledge-synthesizer.js';
+import type { ChainRunner } from '../flows/chain-runner.js';
+import type { JobQueue } from '../queue/job-queue.js';
+import type { PipelineRunner } from '../queue/pipeline-runner.js';
 
 /**
  * Configuration for creating an agent runtime.
@@ -48,6 +55,10 @@ export interface AgentRuntimeConfig {
   logLevel?: LogLevel;
   /** Path to shared global vault. Default: ~/.soleri/vault.db */
   sharedVaultPath?: string;
+  /** Enable Cognee vector search integration. Default: false (opt-in). */
+  cognee?: boolean;
+  /** Path to the agent's root directory (containing agent.yaml, instructions/, etc.). Optional — set by engine binary. */
+  agentDir?: string;
 }
 
 /**
@@ -63,7 +74,8 @@ export interface AgentRuntime {
   planner: Planner;
   curator: Curator;
   governance: Governance;
-  cognee: CogneeClient;
+  /** Cognee vector search client. Null when Cognee integration is disabled. */
+  cognee: CogneeClient | null;
   loop: LoopManager;
   identityManager: IdentityManager;
   intentRouter: IntentRouter;
@@ -72,7 +84,8 @@ export interface AgentRuntime {
   telemetry: Telemetry;
   projectRegistry: ProjectRegistry;
   templateManager: TemplateManager;
-  syncManager: CogneeSyncManager;
+  /** Cognee sync manager. Null when Cognee integration is disabled. */
+  syncManager: CogneeSyncManager | null;
   intakePipeline: IntakePipeline;
   /** Mutable auth policy — controls facade dispatch enforcement. */
   authPolicy: AuthPolicy;
@@ -96,6 +109,20 @@ export interface AgentRuntime {
   agencyManager: AgencyManager;
   /** Knowledge review — team review workflows (submit/approve/reject). */
   knowledgeReview: KnowledgeReview;
+  /** Link manager — Zettelkasten bidirectional linking with auto-link on ingestion. */
+  linkManager: LinkManager;
+  /** Learning radar — automatic pattern detection from session signals. */
+  learningRadar: LearningRadar;
+  /** Text ingester — ingest articles, transcripts, and plain text into vault. */
+  textIngester: TextIngester;
+  /** Knowledge synthesizer — turn vault knowledge into briefs, outlines, posts. */
+  knowledgeSynthesizer: KnowledgeSynthesizer;
+  /** Chain runner — composable multi-step workflows with data flow and gates. */
+  chainRunner: ChainRunner;
+  /** Job queue — SQLite-backed async job processing with DAG dependencies. */
+  jobQueue: JobQueue;
+  /** Pipeline runner — background polling loop for job execution. */
+  pipelineRunner: PipelineRunner;
   /** Timestamp (ms since epoch) when this runtime was created. */
   createdAt: number;
   /** Close the vault database connection. Call on shutdown. */