@soleri/core 7.0.0 → 8.0.0

package/src/runtime/memory-extra-ops.ts

@@ -1,11 +1,14 @@
 /**
- * Extended memory operations — 8 ops for advanced memory management.
+ * Extended memory operations — 18 ops for advanced memory management.
  *
  * These complement the 4 base memory ops in core-ops.ts:
  *   memory_search, memory_capture, memory_list, session_capture
  *
- * New ops: memory_delete, memory_stats, memory_export, memory_import,
- *          memory_prune, memory_deduplicate, memory_topics, memory_by_project
+ * CRUD: memory_delete, memory_stats, memory_export, memory_import,
+ *       memory_prune, memory_deduplicate, memory_topics, memory_by_project
+ * Governance (#213): memory_get, session_search, knowledge_audit, smart_capture,
+ *       knowledge_health, merge_patterns, knowledge_reorganize,
+ *       list_project_knowledge, list_projects, knowledge_debug
  */
 
 import { z } from 'zod';
@@ -13,7 +16,7 @@ import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 
 export function createMemoryExtraOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault } = runtime;
+  const { vault, brain, curator, linkManager } = runtime;
 
   return [
     {
@@ -116,6 +119,11 @@ export function createMemoryExtraOps(runtime: AgentRuntime): OpDefinition[] {
           topics: (m.topics as string[]) ?? [],
           filesModified: (m.filesModified as string[]) ?? [],
           toolsUsed: (m.toolsUsed as string[]) ?? [],
+          intent: (m.intent as string) ?? null,
+          decisions: (m.decisions as string[]) ?? [],
+          currentState: (m.currentState as string) ?? null,
+          nextSteps: (m.nextSteps as string[]) ?? [],
+          vaultEntriesReferenced: (m.vaultEntriesReferenced as string[]) ?? [],
           createdAt: m.createdAt as number,
           archivedAt: (m.archivedAt as number | null) ?? null,
         }));
@@ -182,5 +190,305 @@ export function createMemoryExtraOps(runtime: AgentRuntime): OpDefinition[] {
         return { count: groups.length, projects: groups };
       },
     },
+
+    // ─── Knowledge Governance (#213) ─────────────────────────────────
+
+    {
+      name: 'memory_get',
+      description: 'Get a single memory entry by ID.',
+      auth: 'read',
+      schema: z.object({
+        id: z.string().describe('Memory ID'),
+      }),
+      handler: async (params) => {
+        const memory = vault.getMemory(params.id as string);
+        if (!memory) return { found: false, id: params.id };
+        return memory;
+      },
+    },
+    {
+      name: 'session_search',
+      description: 'Search session memories with optional includeArchived flag.',
+      auth: 'read',
+      schema: z.object({
+        query: z.string().describe('Search query'),
+        includeArchived: z.boolean().optional().default(false),
+        intent: z.string().optional().describe('Filter by session intent'),
+        limit: z.number().optional().default(10),
+      }),
+      handler: async (params) => {
+        // Use searchMemories with type=session
+        const results = vault.searchMemories(params.query as string, {
+          type: 'session',
+          intent: params.intent as string | undefined,
+          limit: params.limit as number,
+        });
+        // If includeArchived, also search archived
+        if (params.includeArchived) {
+          try {
+            const archived = vault
+              .getProvider()
+              .all<Record<string, unknown>>(
+                "SELECT * FROM memories WHERE type = 'session' AND archived_at IS NOT NULL AND summary LIKE @q ORDER BY created_at DESC LIMIT @limit",
+                { q: `%${params.query}%`, limit: params.limit as number },
+              );
+            // Minimal parsing for archived results
+            const archivedMemories = archived.map((r) => ({
+              id: r.id,
+              summary: r.summary,
+              intent: r.intent ?? null,
+              createdAt: r.created_at,
+              archived: true,
+            }));
+            return { active: results, archived: archivedMemories };
+          } catch {
+            return { active: results, archived: [] };
+          }
+        }
+        return { results };
+      },
+    },
+    {
+      name: 'knowledge_audit',
+      description:
+        'Audit vault knowledge quality — coverage, freshness, tag health, recommendations.',
+      auth: 'read',
+      handler: async () => {
+        const healthAudit = curator.healthAudit();
+        const vaultStats = vault.stats();
+        const brainStats = brain.getStats();
+        return {
+          vault: {
+            totalEntries: vaultStats.totalEntries,
+            byType: vaultStats.byType,
+            byDomain: vaultStats.byDomain,
+          },
+          health: healthAudit,
+          brain: brainStats,
+        };
+      },
+    },
+    {
+      name: 'smart_capture',
+      description:
+        'Capture knowledge with auto-classification — infers type, tags, and severity from content.',
+      auth: 'write',
+      schema: z.object({
+        title: z.string(),
+        description: z.string(),
+        domain: z.string().optional().default('general'),
+        context: z.string().optional(),
+        why: z.string().optional(),
+      }),
+      handler: async (params) => {
+        const id = `smart-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        // Auto-infer type from keywords
+        const desc = (params.description as string).toLowerCase();
+        const inferredType: 'pattern' | 'anti-pattern' =
+          desc.includes('never') ||
+          desc.includes("don't") ||
+          desc.includes('avoid') ||
+          desc.includes('anti')
+            ? 'anti-pattern'
+            : 'pattern';
+        const inferredSeverity: 'critical' | 'warning' | 'suggestion' =
+          desc.includes('must') || desc.includes('critical') || desc.includes('always')
+            ? 'critical'
+            : desc.includes('should') || desc.includes('important')
+              ? 'warning'
+              : 'suggestion';
+
+        const result = brain.enrichAndCapture({
+          id,
+          type: inferredType,
+          domain: params.domain as string,
+          title: params.title as string,
+          description: params.description as string,
+          severity: inferredSeverity,
+          context: params.context as string | undefined,
+          why: params.why as string | undefined,
+        });
+
+        return {
+          ...result,
+          inferred: { type: inferredType, severity: inferredSeverity },
+        };
+      },
+    },
+    {
+      name: 'knowledge_health',
+      description: 'Knowledge base health — freshness, staleness, contradictions, coverage gaps.',
+      auth: 'read',
+      handler: async () => {
+        const audit = curator.healthAudit();
+        const ageReport = vault.getAgeReport();
+        const contradictions = curator.detectContradictions();
+        return {
+          score: audit.score,
+          metrics: audit.metrics,
+          ageDistribution: ageReport,
+          openContradictions: contradictions.filter((c) => c.status === 'open').length,
+          recommendations: audit.recommendations,
+        };
+      },
+    },
+    {
+      name: 'merge_patterns',
+      description: 'Merge two vault entries into one — combines tags, preserves links from both.',
+      auth: 'write',
+      schema: z.object({
+        keepId: z.string().describe('Entry ID to keep (survives the merge)'),
+        removeId: z.string().describe('Entry ID to remove (merged into keepId)'),
+      }),
+      handler: async (params) => {
+        const keepEntry = vault.get(params.keepId as string);
+        const removeEntry = vault.get(params.removeId as string);
+        if (!keepEntry) return { error: `Entry not found: ${params.keepId}` };
+        if (!removeEntry) return { error: `Entry not found: ${params.removeId}` };
+
+        // Merge tags
+        const mergedTags = [...new Set([...keepEntry.tags, ...removeEntry.tags])];
+
+        // Update the kept entry with merged tags and enriched description
+        vault.update(params.keepId as string, {
+          tags: mergedTags,
+          description: keepEntry.description.includes(removeEntry.title)
+            ? keepEntry.description
+            : `${keepEntry.description}\n\n[Merged from: ${removeEntry.title}] ${removeEntry.description}`,
+        });
+
+        // Transfer links from removed entry to kept entry
+        if (linkManager) {
+          try {
+            const links = linkManager.getLinks(params.removeId as string);
+            for (const link of links) {
+              const otherId = link.sourceId === params.removeId ? link.targetId : link.sourceId;
+              if (otherId !== params.keepId) {
+                try {
+                  linkManager.addLink(
+                    params.keepId as string,
+                    otherId,
+                    link.linkType,
+                    `merged from ${params.removeId}`,
+                  );
+                } catch {
+                  /* duplicate link — skip */
+                }
+              }
+            }
+          } catch {
+            /* link manager ops failed — non-critical */
+          }
+        }
+
+        // Remove the merged entry
+        vault.remove(params.removeId as string);
+
+        return {
+          merged: true,
+          keptId: params.keepId,
+          removedId: params.removeId,
+          mergedTags,
+        };
+      },
+    },
+    {
+      name: 'knowledge_reorganize',
+      description: 'Re-categorize vault entries — change domain, retag, with dry-run preview.',
+      auth: 'write',
+      schema: z.object({
+        fromDomain: z.string().describe('Current domain to reorganize'),
+        toDomain: z.string().describe('Target domain'),
+        addTags: z.array(z.string()).optional().describe('Tags to add to all affected entries'),
+        removeTags: z
+          .array(z.string())
+          .optional()
+          .describe('Tags to remove from all affected entries'),
+        dryRun: z.boolean().optional().default(true).describe('Preview without applying'),
+      }),
+      handler: async (params) => {
+        const entries = vault.list({ limit: 10000 }).filter((e) => e.domain === params.fromDomain);
+        const addTags = (params.addTags as string[]) ?? [];
+        const removeTags = new Set((params.removeTags as string[]) ?? []);
+        const toDomain = params.toDomain as string;
+
+        if (params.dryRun) {
+          return {
+            dryRun: true,
+            affected: entries.length,
+            fromDomain: params.fromDomain,
+            toDomain,
+            entries: entries.slice(0, 20).map((e) => ({ id: e.id, title: e.title })),
+          };
+        }
+
+        let updated = 0;
+        for (const entry of entries) {
+          const newTags = [...entry.tags.filter((t) => !removeTags.has(t)), ...addTags];
+          vault.update(entry.id, { domain: toDomain, tags: [...new Set(newTags)] });
+          updated++;
+        }
+
+        return { applied: true, updated, fromDomain: params.fromDomain, toDomain };
+      },
+    },
+    {
+      name: 'list_project_knowledge',
+      description: 'List vault entries scoped to a project (by tier tag or domain).',
+      auth: 'read',
+      schema: z.object({
+        project: z.string().describe('Project name or path to filter by'),
+        limit: z.number().optional().default(50),
+      }),
+      handler: async () => {
+        // Entries with tier='project' or tagged with project name
+        const all = vault.list({ limit: 10000 });
+        const projectEntries = all.filter((e) => e.tier === 'project' || e.origin === 'user');
+        return {
+          count: projectEntries.length,
+          entries: projectEntries.slice(0, 50).map((e) => ({
+            id: e.id,
+            title: e.title,
+            type: e.type,
+            domain: e.domain,
+            tier: e.tier,
+          })),
+        };
+      },
+    },
+    {
+      name: 'list_projects',
+      description:
+        'List all distinct domains and tiers in the vault — shows knowledge distribution.',
+      auth: 'read',
+      handler: async () => {
+        const stats = vault.stats();
+        return {
+          domains: Object.entries(stats.byDomain ?? {}).map(([domain, count]) => ({
+            domain,
+            count,
+          })),
+          types: Object.entries(stats.byType ?? {}).map(([type, count]) => ({ type, count })),
+          total: stats.totalEntries,
+        };
+      },
+    },
+    {
+      name: 'knowledge_debug',
+      description:
+        'Debug knowledge system internals — vault DB stats, brain state, curator state, memory counts.',
+      auth: 'admin',
+      handler: async () => {
+        return {
+          vault: {
+            stats: vault.stats(),
+            recentCount: vault.getRecent(1).length > 0 ? 'has entries' : 'empty',
+          },
+          brain: brain.getStats(),
+          curator: curator.getStatus(),
+          memory: vault.memoryStats(),
+        };
+      },
+    },
   ];
 }

package/src/runtime/planning-extra-ops.ts

@@ -13,6 +13,7 @@ import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 import type { DriftItem, TaskEvidence } from '../planning/planner.js';
+import { collectGitEvidence } from '../planning/evidence-collector.js';
 import { matchPlaybooks, type PlaybookMatchResult } from '../playbooks/index.js';
 import { entryToPlaybookDefinition } from '../playbooks/index.js';
 
@@ -714,5 +715,98 @@ export function createPlanningExtraOps(runtime: AgentRuntime): OpDefinition[] {
         }
       },
     },
+
+    // ─── Evidence-Based Reconciliation (#206) ─────────────────────
+    {
+      name: 'plan_reconcile_with_evidence',
+      description:
+        'Cross-reference plan tasks against git diff to produce an evidence-based drift report. ' +
+        'Shows which tasks have matching file changes, which are missing, and what unplanned work was done.',
+      auth: 'read',
+      schema: z.object({
+        planId: z.string().describe('Plan ID to verify against git'),
+        projectPath: z.string().describe('Project root (must be a git repo)'),
+        baseBranch: z
+          .string()
+          .optional()
+          .default('main')
+          .describe('Branch to diff against (default: main)'),
+      }),
+      handler: async (params) => {
+        try {
+          const plan = planner.get(params.planId as string);
+          if (!plan) return { error: `Plan not found: ${params.planId}` };
+
+          return collectGitEvidence(
+            plan,
+            params.projectPath as string,
+            params.baseBranch as string,
+          );
+        } catch (err) {
+          return { error: (err as Error).message };
+        }
+      },
+    },
+
+    // ─── Purge Plans (#215) ──────────────────────────────────────────
+    {
+      name: 'plan_purge',
+      description:
+        'Permanently delete plans by mode: "archived" (only archived), "completed" (completed + archived), ' +
+        '"stale" (draft/approved older than 24h), or "specific" (by IDs). Use dryRun to preview.',
+      auth: 'admin',
+      schema: z.object({
+        mode: z.enum(['archived', 'completed', 'stale', 'specific']).describe('Purge mode'),
+        planIds: z.array(z.string()).optional().describe('Plan IDs for specific mode'),
+        dryRun: z.boolean().optional().default(false).describe('Preview without deleting'),
+      }),
+      handler: async (params) => {
+        const mode = params.mode as string;
+        const dryRun = params.dryRun as boolean;
+        const plans = planner.list();
+        const now = Date.now();
+        const staleThresholdMs = 24 * 60 * 60 * 1000;
+
+        let toPurge: typeof plans;
+        if (mode === 'archived') {
+          toPurge = plans.filter((p) => p.status === 'archived');
+        } else if (mode === 'completed') {
+          toPurge = plans.filter((p) => p.status === 'completed' || p.status === 'archived');
+        } else if (mode === 'stale') {
+          toPurge = plans.filter(
+            (p) =>
+              (p.status === 'draft' || p.status === 'approved' || p.status === 'brainstorming') &&
+              p.createdAt &&
+              now - p.createdAt > staleThresholdMs,
+          );
+        } else if (mode === 'specific') {
+          const ids = new Set((params.planIds as string[]) ?? []);
+          toPurge = plans.filter((p) => ids.has(p.id));
+        } else {
+          return { error: `Unknown purge mode: ${mode}` };
+        }
+
+        if (dryRun) {
+          return {
+            dryRun: true,
+            mode,
+            wouldPurge: toPurge.length,
+            plans: toPurge.map((p) => ({ id: p.id, status: p.status, objective: p.objective })),
+          };
+        }
+
+        let purged = 0;
+        for (const p of toPurge) {
+          try {
+            planner.remove(p.id);
+            purged++;
+          } catch {
+            // Skip plans that can't be removed
+          }
+        }
+
+        return { purged, mode };
+      },
+    },
   ];
 }

package/src/runtime/playbook-ops.ts

@@ -88,7 +88,7 @@ export function createPlaybookOps(runtime: AgentRuntime): OpDefinition[] {
           validation?: string;
         }>;
 
-        const steps = rawSteps.map((s, i) => ({ ...s, order: i + 1 }));
+        const steps = rawSteps.map((s, i) => Object.assign({}, s, { order: i + 1 }));
         const id =
           (params.id as string | undefined) ??
           `playbook-${domain}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

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();