@soleri/core 7.0.0 → 8.1.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';
 
 /**
@@ -96,7 +106,8 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   }
 
   // Brain — intelligence layer (TF-IDF scoring, auto-tagging, dedup)
-  const brain = new Brain(vault, cognee ?? undefined);
+  // 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);
@@ -130,9 +141,15 @@ 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 (only when Cognee enabled)
@@ -146,8 +163,13 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     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();
@@ -217,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,
@@ -228,6 +251,119 @@ 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();

package/src/runtime/session-briefing.ts

@@ -0,0 +1,175 @@
+/**
+ * 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;
+
+        // 0. Day-one welcome (vault has few non-playbook entries)
+        try {
+          const stats = vault.stats();
+          const nonPlaybook = stats.totalEntries - (stats.byType?.playbook ?? 0);
+          if (nonPlaybook < 10) {
+            sections.push({
+              label: 'Welcome',
+              content: `Vault has ${nonPlaybook} knowledge entries. Capture patterns as you work — the brain learns from every session. Use op:capture_knowledge to persist insights.`,
+            });
+          }
+        } catch {
+          // Vault stats unavailable — skip
+        }
+
+        // 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 [
     {
@@ -330,13 +328,11 @@ export function createVaultLinkingOps(runtime: AgentRuntime): OpDefinition[] {
 
           try {
             const result = await llmClient.complete({
-              provider: llmClient.isAvailable().anthropic ? 'anthropic' : 'openai',
-              model: llmClient.isAvailable().anthropic ? 'claude-sonnet-4-20250514' : 'gpt-4o-mini',
               systemPrompt: EVAL_SYSTEM_PROMPT,
               userPrompt: pairsText,
               maxTokens: 2000,
-              caller: 'relink_vault',
-              task: 'link-evaluation',
+              caller: 'vault-linking',
+              task: 'evaluate-links',
             });
             llmCalls++;
 

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).
@@ -61,12 +76,60 @@ export class Vault {
         providerOrPath instanceof SQLitePersistenceProvider ? providerOrPath : null;
     }
     this.initialize();
+    this.checkFormatVersion();
+  }
+
+  /**
+   * Vault format version — tracks schema changes for migration safety.
+   * Increment when schema changes in a way that requires migration.
+   *
+   * History:
+   *   1 — Initial schema (v8.0.0): entries, memories, brain_feedback, FTS5
+   */
+  static readonly FORMAT_VERSION = 1;
+
+  private checkFormatVersion(): void {
+    const row = this.provider.get<{ user_version: number }>('PRAGMA user_version');
+    const current = row?.user_version ?? 0;
+
+    if (current === 0) {
+      // Fresh database — stamp with current version
+      this.provider.run(`PRAGMA user_version = ${Vault.FORMAT_VERSION}`);
+    } else if (current > Vault.FORMAT_VERSION) {
+      throw new Error(
+        `Vault format version ${current} is newer than engine supports (${Vault.FORMAT_VERSION}). ` +
+          `Upgrade @soleri/core to a compatible version.`,
+      );
+    }
+    // current < FORMAT_VERSION → future: run migration scripts here
   }
 
   setSyncManager(mgr: import('../cognee/sync-manager.js').CogneeSyncManager): void {
     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 +203,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 +418,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 +762,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 +813,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 +824,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 +836,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 +849,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 +1335,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,
   };