@soleri/core 7.0.0 → 8.0.0

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.
@@ -50,6 +57,8 @@ export interface AgentRuntimeConfig {
   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;
 }
 
 /**
@@ -100,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. */

package/src/runtime/vault-linking-ops.ts

@@ -11,7 +11,6 @@
 import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
-import { LinkManager } from '../vault/linking.js';
 
 const EVAL_SYSTEM_PROMPT = `You evaluate pairs of knowledge entries to determine if they should be linked in a Zettelkasten vault. For EACH pair, decide:
 - If meaningfully related → return { "link": true, "type": "<type>", "note": "<1 sentence why>" }
@@ -26,8 +25,7 @@ Link types:
 Rules: Same category alone is NOT enough. Be selective. Return a JSON array.`;
 
 export function createVaultLinkingOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault } = runtime;
-  const linkManager = new LinkManager(vault.getProvider());
+  const { vault, linkManager } = runtime;
 
   return [
     {

package/src/vault/vault.ts

@@ -2,6 +2,7 @@ import type { PersistenceProvider } from '../persistence/types.js';
 import { SQLitePersistenceProvider } from '../persistence/sqlite-provider.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 import { computeContentHash } from './content-hash.js';
+import type { LinkManager } from './linking.js';
 
 export interface SearchResult {
   entry: IntelligenceEntry;
@@ -29,6 +30,16 @@ export interface Memory {
   topics: string[];
   filesModified: string[];
   toolsUsed: string[];
+  /** What the user was trying to accomplish. */
+  intent: string | null;
+  /** Key decisions made and their rationale. */
+  decisions: string[];
+  /** Where things stand at capture time. */
+  currentState: string | null;
+  /** What should happen next session. */
+  nextSteps: string[];
+  /** Vault entries that informed this session. */
+  vaultEntriesReferenced: string[];
   createdAt: number;
   archivedAt: number | null;
 }
@@ -42,6 +53,10 @@ export class Vault {
   private provider: PersistenceProvider;
   private sqliteProvider: SQLitePersistenceProvider | null;
   private syncManager: import('../cognee/sync-manager.js').CogneeSyncManager | null = null;
+  private linkManager: LinkManager | null = null;
+  private autoLinkEnabled = true;
+  /** Minimum number of FTS5 suggestions to auto-link. Top N are linked. */
+  private autoLinkMaxLinks = 3;
 
   /**
    * Create a Vault with a PersistenceProvider or a SQLite path (backward compat).
@@ -67,6 +82,28 @@ export class Vault {
     this.syncManager = mgr;
   }
 
+  setLinkManager(mgr: LinkManager, opts?: { enabled?: boolean; maxLinks?: number }): void {
+    this.linkManager = mgr;
+    if (opts?.enabled !== undefined) this.autoLinkEnabled = opts.enabled;
+    if (opts?.maxLinks !== undefined) this.autoLinkMaxLinks = opts.maxLinks;
+  }
+
+  /**
+   * Auto-link a newly added entry using FTS5 suggestions.
+   * Called after seed() for each entry. Creates links for top N suggestions.
+   */
+  private autoLink(entryId: string): void {
+    if (!this.linkManager || !this.autoLinkEnabled) return;
+    try {
+      const suggestions = this.linkManager.suggestLinks(entryId, this.autoLinkMaxLinks);
+      for (const s of suggestions) {
+        this.linkManager.addLink(entryId, s.entryId, s.suggestedType, `auto: ${s.reason}`);
+      }
+    } catch {
+      // Auto-linking is best-effort — never block ingestion
+    }
+  }
+
   /** Backward-compatible factory. */
   static createWithSQLite(dbPath: string = ':memory:'): Vault {
     return new Vault(dbPath);
@@ -140,7 +177,23 @@ export class Vault {
       CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
         id, context, summary, topics,
         content='memories', content_rowid='rowid', tokenize='porter unicode61'
-      );
+      );`);
+
+    // Add new columns if they don't exist (backward-compatible migration)
+    const memCols = this.provider
+      .all<{ name: string }>(`PRAGMA table_info(memories)`)
+      .map((r) => r.name);
+    if (!memCols.includes('intent')) {
+      this.provider.execSql(`
+        ALTER TABLE memories ADD COLUMN intent TEXT;
+        ALTER TABLE memories ADD COLUMN decisions TEXT NOT NULL DEFAULT '[]';
+        ALTER TABLE memories ADD COLUMN current_state TEXT;
+        ALTER TABLE memories ADD COLUMN next_steps TEXT NOT NULL DEFAULT '[]';
+        ALTER TABLE memories ADD COLUMN vault_entries_referenced TEXT NOT NULL DEFAULT '[]';
+      `);
+    }
+
+    this.provider.execSql(`
       CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
         INSERT INTO memories_fts(rowid,id,context,summary,topics) VALUES(new.rowid,new.id,new.context,new.summary,new.topics);
       END;
@@ -339,6 +392,13 @@ export class Vault {
           this.syncManager.enqueue('ingest', entry.id, entry);
         }
       }
+      // Auto-link after all entries are inserted (so they can link to each other).
+      // Skip for large batches (>100) — use relink_vault for bulk imports.
+      if (entries.length <= 100) {
+        for (const entry of entries) {
+          this.autoLink(entry.id);
+        }
+      }
       return count;
     });
   }
@@ -676,7 +736,7 @@ export class Vault {
     }
     return {
       total: rows.length,
-      buckets: bucketDefs.map((b, i) => ({ ...b, count: counts[i] })),
+      buckets: bucketDefs.map((b, i) => Object.assign({}, b, { count: counts[i] })),
       oldestTimestamp: oldest,
       newestTimestamp: newest,
     };
@@ -727,7 +787,8 @@ export class Vault {
   captureMemory(memory: Omit<Memory, 'id' | 'createdAt' | 'archivedAt'>): Memory {
     const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     this.provider.run(
-      `INSERT INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used) VALUES (@id, @projectPath, @type, @context, @summary, @topics, @filesModified, @toolsUsed)`,
+      `INSERT INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used, intent, decisions, current_state, next_steps, vault_entries_referenced)
+       VALUES (@id, @projectPath, @type, @context, @summary, @topics, @filesModified, @toolsUsed, @intent, @decisions, @currentState, @nextSteps, @vaultEntriesReferenced)`,
       {
         id,
         projectPath: memory.projectPath,
@@ -737,6 +798,11 @@ export class Vault {
         topics: JSON.stringify(memory.topics),
         filesModified: JSON.stringify(memory.filesModified),
         toolsUsed: JSON.stringify(memory.toolsUsed),
+        intent: memory.intent ?? null,
+        decisions: JSON.stringify(memory.decisions ?? []),
+        currentState: memory.currentState ?? null,
+        nextSteps: JSON.stringify(memory.nextSteps ?? []),
+        vaultEntriesReferenced: JSON.stringify(memory.vaultEntriesReferenced ?? []),
       },
     );
     return this.getMemory(id)!;
@@ -744,7 +810,7 @@ export class Vault {
 
   searchMemories(
     query: string,
-    options?: { type?: string; projectPath?: string; limit?: number },
+    options?: { type?: string; projectPath?: string; intent?: string; limit?: number },
   ): Memory[] {
     const limit = options?.limit ?? 10;
     const filters: string[] = ['m.archived_at IS NULL'];
@@ -757,6 +823,10 @@ export class Vault {
       filters.push('m.project_path = @projectPath');
       fp.projectPath = options.projectPath;
     }
+    if (options?.intent) {
+      filters.push('m.intent = @intent');
+      fp.intent = options.intent;
+    }
     const wc = filters.length > 0 ? `AND ${filters.join(' AND ')}` : '';
     try {
       const rows = this.provider.all<Record<string, unknown>>(
@@ -1239,6 +1309,11 @@ function rowToMemory(row: Record<string, unknown>): Memory {
     topics: JSON.parse((row.topics as string) || '[]'),
     filesModified: JSON.parse((row.files_modified as string) || '[]'),
     toolsUsed: JSON.parse((row.tools_used as string) || '[]'),
+    intent: (row.intent as string) ?? null,
+    decisions: JSON.parse((row.decisions as string) || '[]'),
+    currentState: (row.current_state as string) ?? null,
+    nextSteps: JSON.parse((row.next_steps as string) || '[]'),
+    vaultEntriesReferenced: JSON.parse((row.vault_entries_referenced as string) || '[]'),
     createdAt: row.created_at as number,
     archivedAt: (row.archived_at as number) ?? null,
   };