@soleri/core 8.0.0 → 8.1.0

package/src/domain-packs/pack-runtime.ts

@@ -14,7 +14,7 @@ import type { Vault } from '../vault/vault.js';
  */
 export interface PackProjectContext {
   id: string;
-  name: string;
+  name?: string;
   path: string;
   colors?: {
     [scale: string]: {
@@ -49,7 +49,7 @@ export interface PackRuntime {
   getProject(projectId: string): PackProjectContext | undefined;
 
   /** List all registered projects */
-  listProjects(): Array<{ id: string; name: string; path: string }>;
+  listProjects(): Array<{ id: string; name?: string; path: string }>;
 
   /** Create a session check (for tool chaining) */
   createCheck(type: string, data: Record<string, unknown>): string;
@@ -70,8 +70,8 @@ export interface PackRuntime {
 export function createPackRuntime(runtime: {
   vault: Vault;
   projectRegistry: {
-    getProject(id: string): PackProjectContext | undefined;
-    listProjects(): Array<{ id: string; name: string; path: string }>;
+    get(id: string): PackProjectContext | null;
+    list(): Array<{ id: string; name?: string; path: string }>;
   };
   sessionStore?: {
     createCheck(type: string, data: Record<string, unknown>): string;
@@ -81,8 +81,8 @@ export function createPackRuntime(runtime: {
 }): PackRuntime {
   return {
     vault: runtime.vault,
-    getProject: (id) => runtime.projectRegistry.getProject(id),
-    listProjects: () => runtime.projectRegistry.listProjects(),
+    getProject: (id) => runtime.projectRegistry.get(id) ?? undefined,
+    listProjects: () => runtime.projectRegistry.list(),
     createCheck: (type, data) => {
       if (!runtime.sessionStore) throw new Error('Session store not available');
       return runtime.sessionStore.createCheck(type, data);

package/src/domain-packs/types.ts

@@ -93,8 +93,14 @@ export interface DomainPack {
   requires?: string[];
   /** Called after pack is installed (one-time setup). */
   onInstall?: (runtime: AgentRuntime) => Promise<void>;
-  /** Called each time the agent starts (runtime initialization). */
-  onActivate?: (runtime: AgentRuntime) => Promise<void>;
+  /**
+   * Called each time the agent starts (runtime initialization).
+   *
+   * Receives `PackRuntime` (narrowed interface with vault, projects, session checks).
+   * The full `AgentRuntime` is passed as second argument for backwards compatibility
+   * but is deprecated — packs should only use `PackRuntime`.
+   */
+  onActivate?: (packRuntime: PackRuntime, runtime?: AgentRuntime) => Promise<void>;
 }
 
 // ---------------------------------------------------------------------------

package/src/engine/bin/soleri-engine.ts

@@ -117,6 +117,14 @@ async function main(): Promise<void> {
   // 6. Seed default playbooks
   seedDefaultPlaybooks(runtime.vault);
 
+  // Log vault stats for first-run visibility
+  const vaultStats = runtime.vault.stats();
+  console.error(
+    `${tag} Vault: ${vaultStats.totalEntries} entries (${Object.entries(vaultStats.byType ?? {})
+      .map(([t, n]) => `${n} ${t}`)
+      .join(', ')})`,
+  );
+
   // 7. Load domain packs
   const packs = (config.packs ?? []) as Array<{ name: string; package: string; version?: string }>;
   const loadedPacks: Array<{ name: string; facades?: Array<{ name: string; ops: unknown[] }> }> =
@@ -129,9 +137,12 @@ async function main(): Promise<void> {
       const manifests = await loadDomainPacksFromConfig(refs);
 
       // Packs activate sequentially — order may matter for dependencies
+      const { createPackRuntime } = await import('../../domain-packs/pack-runtime.js');
+      const narrowedRuntime = createPackRuntime(runtime);
+
       for (const manifest of manifests) {
         if (manifest.onActivate) {
-          await manifest.onActivate(runtime); // eslint-disable-line no-await-in-loop
+          await manifest.onActivate(narrowedRuntime, runtime); // eslint-disable-line no-await-in-loop
         }
         loadedPacks.push(manifest);
         console.error(`${tag} Domain pack: ${manifest.name}`);
@@ -178,7 +189,7 @@ async function main(): Promise<void> {
   }));
 
   // 12. Register all engine tools
-  const { tools, totalOps } = registerEngine(server, runtime, {
+  const { tools, totalOps, registerTool } = registerEngine(server, runtime, {
     agentId,
     coreOps,
     domains: identity.domains,
@@ -195,6 +206,10 @@ async function main(): Promise<void> {
 
   console.error(`${tag} Registered ${tools.length} tools (${totalOps} ops)`);
 
+  // Enable hot reload for post-boot pack/plugin installation
+  const { setHotRegister } = await import('../../runtime/pack-ops.js');
+  setHotRegister(registerTool);
+
   // 13. Connect stdio transport
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/src/engine/index.ts

@@ -17,3 +17,5 @@ export { registerEngine } from './register-engine.js';
 export type { EngineRegistrationOptions, EngineRegistrationResult } from './register-engine.js';
 export { createCoreOps } from './core-ops.js';
 export type { AgentIdentityConfig } from './core-ops.js';
+export { ENGINE_MODULE_MANIFEST, CORE_KEY_OPS } from './module-manifest.js';
+export type { ModuleManifestEntry } from './module-manifest.js';

package/src/engine/module-manifest.ts

@@ -0,0 +1,99 @@
+/**
+ * Soleri Engine Module Manifest
+ *
+ * Single source of truth for engine module names, descriptions, and key ops.
+ * Used by register-engine.ts at runtime and by @soleri/forge for template generation.
+ *
+ * This file is intentionally dependency-free so it can be imported by any package.
+ */
+
+export interface ModuleManifestEntry {
+  /** Suffix for tool name: {agentId}_{suffix} */
+  suffix: string;
+  /** Human-readable description */
+  description: string;
+  /** Representative ops shown in placeholder tables (max 4) */
+  keyOps: string[];
+  /** If true, module requires a runtime condition to register */
+  conditional?: boolean;
+}
+
+/**
+ * Canonical list of engine modules.
+ * Order here determines order in generated tool tables.
+ */
+export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
+  {
+    suffix: 'vault',
+    description: 'Knowledge management — search, CRUD, import/export, intake, archival.',
+    keyOps: ['search_intelligent', 'capture_knowledge', 'capture_quick'],
+  },
+  {
+    suffix: 'plan',
+    description: 'Plan lifecycle — create, approve, execute, reconcile, complete, grading.',
+    keyOps: ['create_plan', 'approve_plan', 'plan_split', 'plan_reconcile'],
+  },
+  {
+    suffix: 'brain',
+    description: 'Learning system — intelligence pipeline, strengths, feedback, sessions.',
+    keyOps: ['recommend', 'strengths', 'feedback'],
+  },
+  {
+    suffix: 'memory',
+    description: 'Session & cross-project memory — capture, search, dedup, promote.',
+    keyOps: ['memory_search', 'memory_capture', 'session_capture'],
+  },
+  {
+    suffix: 'admin',
+    description: 'Infrastructure — health, config, telemetry, tokens, LLM, prompts.',
+    keyOps: ['admin_health', 'admin_tool_list', 'admin_diagnostic'],
+  },
+  {
+    suffix: 'curator',
+    description: 'Quality — duplicate detection, contradictions, grooming, health audit.',
+    keyOps: ['curator_groom', 'curator_status', 'curator_health'],
+  },
+  {
+    suffix: 'loop',
+    description: 'Iterative validation loops — start, iterate, cancel, complete, history.',
+    keyOps: ['loop_start', 'loop_status', 'loop_cancel'],
+  },
+  {
+    suffix: 'orchestrate',
+    description:
+      'Execution orchestration — project registration, playbooks, plan/execute/complete.',
+    keyOps: ['orchestrate_plan', 'orchestrate_execute', 'orchestrate_complete'],
+  },
+  {
+    suffix: 'control',
+    description: 'Agent behavior — identity, intent routing, morphing, guidelines, governance.',
+    keyOps: ['route_intent', 'morph', 'get_behavior_rules'],
+  },
+  {
+    suffix: 'context',
+    description: 'Context analysis — entity extraction, knowledge retrieval, confidence scoring.',
+    keyOps: ['context_extract_entities', 'context_retrieve_knowledge', 'context_analyze'],
+  },
+  {
+    suffix: 'agency',
+    description: 'Proactive intelligence — file watching, pattern surfacing, warnings.',
+    keyOps: ['agency_scan_file', 'agency_surface_patterns', 'agency_warnings'],
+  },
+  {
+    suffix: 'chat',
+    description: 'Chat transport — session management, response chunking, authentication.',
+    keyOps: ['chat_send', 'chat_history', 'chat_session'],
+  },
+  {
+    suffix: 'cognee',
+    description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
+    keyOps: ['cognee_search', 'cognee_add', 'cognee_cognify'],
+    conditional: true,
+  },
+];
+
+/** Core facade ops (always present, not in ENGINE_MODULES) */
+export const CORE_KEY_OPS = ['health', 'identity', 'register', 'activate'];
+
+/** Engine major version — used for compatibility checks against domain packs. */
+export const ENGINE_MAJOR_VERSION = 8;

package/src/engine/register-engine.ts

@@ -60,6 +60,12 @@ export interface EngineRegistrationResult {
   tools: string[];
   /** Total op count across all tools */
   totalOps: number;
+  /**
+   * Register a new MCP tool at runtime (hot reload).
+   * Call this after installing a pack or activating a plugin post-boot.
+   * Automatically notifies connected clients via sendToolListChanged().
+   */
+  registerTool: (toolName: string, description: string, ops: OpDefinition[]) => void;
 }
 
 // ─── Module Definition ────────────────────────────────────────────────
@@ -75,7 +81,8 @@ interface ModuleDef {
   condition?: (runtime: AgentRuntime) => boolean;
 }
 
-const ENGINE_MODULES: ModuleDef[] = [
+/** @internal Exported for drift testing — do not use outside engine */
+export const ENGINE_MODULES: ModuleDef[] = [
   {
     suffix: 'vault',
     description: 'Knowledge management — search, CRUD, import/export, intake, archival.',
@@ -233,7 +240,19 @@ export function registerEngine(
     }
   }
 
-  return { tools: registeredTools, totalOps };
+  const registerTool = (toolName: string, description: string, ops: OpDefinition[]) => {
+    registerModuleTool(server, toolName, description, ops, authPolicy);
+    registeredTools.push(toolName);
+    totalOps += ops.length;
+    // Notify connected clients that tool list changed
+    try {
+      (server as unknown as { sendToolListChanged?: () => void }).sendToolListChanged?.();
+    } catch {
+      // Server may not support notifications yet — safe to ignore
+    }
+  };
+
+  return { tools: registeredTools, totalOps, registerTool };
 }
 
 // ─── Tool Registration (No Factory) ──────────────────────────────────

package/src/index.ts

@@ -541,7 +541,6 @@ export type {
 
 // ─── Persistence ───────────────────────────────────────────────────────
 export { SQLitePersistenceProvider } from './persistence/index.js';
-export { PostgresPersistenceProvider, translateSql } from './persistence/index.js';
 export type {
   PersistenceProvider,
   PersistenceParams,

package/src/intake/content-classifier.ts

@@ -60,8 +60,6 @@ export async function classifyChunk(
 ): Promise<ClassifiedItem[]> {
   try {
     const result = await llm.complete({
-      provider: 'openai',
-      model: 'gpt-4o-mini',
       systemPrompt: CLASSIFICATION_PROMPT,
       userPrompt: chunkText,
       maxTokens: 4096,

package/src/llm/llm-client.ts

@@ -160,6 +160,8 @@ interface AnthropicClient {
   };
 }
 
+type ResolvedLLMOptions = LLMCallOptions & { model: string; provider: 'openai' | 'anthropic' };
+
 export class LLMClient {
   private openaiKeyPool: KeyPool;
   private anthropicKeyPool: KeyPool;
@@ -181,11 +183,15 @@ export class LLMClient {
 
   async complete(options: LLMCallOptions): Promise<LLMCallResult> {
     const routed = this.router.resolve(options.caller, options.task, options.model);
-    const resolvedOptions = { ...options, model: routed.model, provider: routed.provider };
+    const resolved: ResolvedLLMOptions = {
+      ...options,
+      model: options.model ?? routed.model,
+      provider: options.provider ?? routed.provider,
+    };
 
-    return resolvedOptions.provider === 'anthropic'
-      ? this.callAnthropic(resolvedOptions)
-      : this.callOpenAI(resolvedOptions);
+    return resolved.provider === 'anthropic'
+      ? this.callAnthropic(resolved)
+      : this.callOpenAI(resolved);
   }
 
   isAvailable(): { openai: boolean; anthropic: boolean } {
@@ -203,7 +209,7 @@ export class LLMClient {
   // OPENAI
   // ===========================================================================
 
-  private async callOpenAI(options: LLMCallOptions): Promise<LLMCallResult> {
+  private async callOpenAI(options: ResolvedLLMOptions): Promise<LLMCallResult> {
     const keyPool = this.openaiKeyPool.hasKeys ? this.openaiKeyPool : null;
 
     if (!keyPool) {
@@ -275,7 +281,7 @@ export class LLMClient {
   // ANTHROPIC
   // ===========================================================================
 
-  private async callAnthropic(options: LLMCallOptions): Promise<LLMCallResult> {
+  private async callAnthropic(options: ResolvedLLMOptions): Promise<LLMCallResult> {
     const client = await this.getAnthropicClient();
     if (!client) {
       throw new LLMError('Anthropic API key not configured', { retryable: false });

package/src/llm/oauth-discovery.ts

@@ -43,24 +43,6 @@ export function discoverAnthropicToken(): string | null {
   return token;
 }
 
-/**
- * Clear the cached token (for testing or rotation).
- */
-export function resetTokenCache(): void {
-  cachedToken = null;
-  cacheTimestamp = 0;
-}
-
-/**
- * Get discovery source info (for diagnostics).
- */
-export function getTokenSource(): string {
-  if (process.env.ANTHROPIC_API_KEY) return 'env:ANTHROPIC_API_KEY';
-  if (tryCredentialsFile()) return 'file:credentials';
-  if (tryPlatformKeychain()) return `keychain:${platform()}`;
-  return 'none';
-}
-
 // ─── Discovery Methods ───────────────────────────────────────────────
 
 function tryEnvVar(): string | null {

package/src/llm/types.ts

@@ -43,8 +43,10 @@ export class LLMError extends Error {
 }
 
 export interface LLMCallOptions {
-  provider: 'openai' | 'anthropic';
-  model: string;
+  /** Provider override. If omitted, the model router selects based on caller/task. */
+  provider?: 'openai' | 'anthropic';
+  /** Model override. If omitted, the model router selects based on caller/task. */
+  model?: string;
   systemPrompt: string;
   userPrompt: string;
   temperature?: number;

package/src/packs/pack-installer.ts

@@ -21,6 +21,7 @@ import { loadIntelligenceData } from '../intelligence/loader.js';
 import type { Vault } from '../vault/vault.js';
 import type { PluginRegistry } from '../plugins/plugin-registry.js';
 import type { PluginContext } from '../plugins/types.js';
+import type { PackRuntime } from '../domain-packs/pack-runtime.js';
 
 const MANIFEST_FILENAME = 'soleri-pack.json';
 
@@ -108,7 +109,11 @@ export class PackInstaller {
   /**
    * Install a knowledge pack from a directory.
    */
-  async install(packDir: string, runtimeCtx?: unknown): Promise<InstallResult> {
+  async install(
+    packDir: string,
+    runtimeCtx?: unknown,
+    packRuntime?: PackRuntime,
+  ): Promise<InstallResult> {
     // Validate first
     const validation = this.validate(packDir);
     if (!validation.valid || !validation.manifest) {
@@ -174,6 +179,16 @@ export class PackInstaller {
         }
 
         const ctx: PluginContext = {
+          packRuntime:
+            packRuntime ??
+            ({
+              vault: {},
+              getProject: () => undefined,
+              listProjects: () => [],
+              createCheck: () => '',
+              validateCheck: () => null,
+              validateAndConsume: () => null,
+            } as unknown as PackRuntime),
           runtime: runtimeCtx ?? {},
           manifest: pluginLoaded.manifest,
           directory: packDir,

package/src/persistence/index.ts

@@ -6,4 +6,3 @@ export type {
   FtsSearchOptions,
 } from './types.js';
 export { SQLitePersistenceProvider } from './sqlite-provider.js';
-export { PostgresPersistenceProvider, translateSql } from './postgres-provider.js';

package/src/persistence/types.ts

@@ -35,7 +35,7 @@ export interface PersistenceProvider {
   transaction<T>(fn: () => T): T;
 
   /** Identifies the backend engine. */
-  readonly backend: 'sqlite' | 'postgres';
+  readonly backend: 'sqlite';
 
   /** Full-text search abstraction. */
   ftsSearch<T = Record<string, unknown>>(
@@ -52,12 +52,8 @@ export interface PersistenceProvider {
 }
 
 export interface PersistenceConfig {
-  type: 'sqlite' | 'postgres';
+  type: 'sqlite';
   path: string;
-  /** PostgreSQL connection string. */
-  connectionString?: string;
-  /** PostgreSQL pool size. */
-  poolSize?: number;
 }
 
 export interface FtsSearchOptions {

package/src/plugins/index.ts

@@ -1,5 +1,9 @@
 /**
  * Plugin System — Barrel Exports
+ *
+ * @deprecated Prefer knowledge packs (soleri-pack.json) for new extensions.
+ * The plugin system is maintained for backwards compatibility and is used
+ * internally by the pack installer for facade registration.
  */
 
 export {

package/src/plugins/plugin-registry.ts

@@ -1,6 +1,10 @@
 /**
  * Plugin Registry — tracks loaded plugins and their lifecycle.
  *
+ * @deprecated The plugin system is superseded by knowledge packs (`soleri-pack.json`).
+ * This registry is still used internally by the pack installer to register facades,
+ * but new extensions should use the pack system directly.
+ *
  * Not a singleton — lives on AgentRuntime for testability.
  * Lifecycle: load → register → activate → (deactivate | error)
  */
@@ -161,7 +165,8 @@ export class PluginRegistry {
       throw new Error(`Plugin module "${moduleFile}" must export createFacades(ctx)`);
     } catch (e) {
       throw new Error(
-        `Failed to load plugin module "${moduleFile}": ${e instanceof Error ? e.message : String(e)}`, { cause: e },
+        `Failed to load plugin module "${moduleFile}": ${e instanceof Error ? e.message : String(e)}`,
+        { cause: e },
       );
     }
   }

package/src/plugins/types.ts

@@ -1,9 +1,12 @@
 /**
  * Plugin System — Types & Manifest Schema
  *
- * A plugin is a directory containing a `soleri-plugin.json` manifest
- * and optionally additional intelligence data. Plugins register
- * OpDefinition[] (facades) dynamically without re-scaffolding.
+ * @deprecated Prefer knowledge packs (`soleri-pack.json`) over plugins (`soleri-plugin.json`).
+ * Knowledge packs are a superset of plugins — they support facades, vault entries, skills,
+ * hooks, and capability declarations. Plugins only support facades and intelligence entries.
+ *
+ * This module is maintained for backwards compatibility. New extensions should use
+ * the pack system in `../packs/`. See docs/architecture/extension-tiers.md.
  */
 
 import { z } from 'zod';
@@ -101,8 +104,10 @@ export type PluginFacadeBuilder = (ctx: PluginContext) => FacadeConfig[];
  * Context passed to plugin facade builders during activation.
  */
 export interface PluginContext {
-  /** The agent runtime — full access to vault, brain, planner, etc. */
-  runtime: unknown; // AgentRuntime — kept as unknown to avoid circular deps
+  /** Narrowed runtime — vault, projects, session checks. Preferred over full runtime. */
+  packRuntime: import('../domain-packs/pack-runtime.js').PackRuntime;
+  /** @deprecated Full agent runtime. Use packRuntime instead — only vault, projects, and session checks are guaranteed. */
+  runtime: unknown;
   /** The plugin's own manifest */
   manifest: PluginManifest;
   /** The plugin's directory on disk */

package/src/runtime/claude-md-helpers.ts

@@ -9,7 +9,6 @@
  */
 
 import type { AgentRuntimeConfig } from './types.js';
-import type { OpDefinition } from '../facades/types.js';
 
 // ─── Types ────────────────────────────────────────────────────────────
 
@@ -198,7 +197,7 @@ const ENGINE_RULES_END = '<!-- /soleri:engine-rules -->';
 /**
  * Check if engine rules are present in content.
  */
-export function hasEngineRules(content: string): boolean {
+function hasEngineRules(content: string): boolean {
   return content.includes(ENGINE_RULES_START) && content.includes(ENGINE_RULES_END);
 }
 
@@ -217,20 +216,3 @@ export function injectEngineRulesBlock(content: string, engineRulesContent: stri
   // Append
   return content.trimEnd() + '\n\n' + engineRulesContent + '\n';
 }
-
-/**
- * Extract facade summaries from an ops array (for tools table generation).
- */
-export function extractFacadeSummaries(
-  agentId: string,
-  opsMap: Map<string, OpDefinition[]>,
-): FacadeSummary[] {
-  const summaries: FacadeSummary[] = [];
-  for (const [suffix, ops] of opsMap) {
-    summaries.push({
-      name: `${agentId}_${suffix}`,
-      ops: ops.map((o) => o.name),
-    });
-  }
-  return summaries;
-}

package/src/runtime/facades/admin-facade.ts

@@ -58,8 +58,7 @@ export function createAdminFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       }),
       handler: async (params) => {
         return llmClient.complete({
-          provider: 'openai',
-          model: (params.model as string) ?? '',
+          model: (params.model as string) || undefined,
           systemPrompt: params.systemPrompt as string,
           userPrompt: params.userPrompt as string,
           temperature: params.temperature as number | undefined,

package/src/runtime/pack-ops.ts

@@ -8,6 +8,16 @@ import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 
+export type HotRegisterTool = (toolName: string, description: string, ops: OpDefinition[]) => void;
+
+/** Mutable slot — set after engine registration to enable hot reload. */
+let _hotRegister: HotRegisterTool | null = null;
+
+/** Set the hot-register callback after registerEngine() completes. */
+export function setHotRegister(fn: HotRegisterTool): void {
+  _hotRegister = fn;
+}
+
 export function createPackOps(runtime: AgentRuntime): OpDefinition[] {
   const { packInstaller } = runtime;
 
@@ -36,7 +46,22 @@ export function createPackOps(runtime: AgentRuntime): OpDefinition[] {
         packDir: z.string().describe('Path to the knowledge pack directory.'),
       }),
       handler: async (params) => {
-        return packInstaller.install(params.packDir as string, runtime);
+        const result = await packInstaller.install(params.packDir as string, runtime);
+        // Hot register facades as MCP tools if callback available
+        if (_hotRegister && result.installed && result.facades > 0) {
+          const plugin = runtime.pluginRegistry.get(result.id);
+          if (plugin?.facades) {
+            for (const facade of plugin.facades) {
+              _hotRegister(
+                `${runtime.config.agentId}_${facade.name}`,
+                facade.description,
+                facade.ops,
+              );
+            }
+          }
+          (result as unknown as Record<string, unknown>).hotReloaded = true;
+        }
+        return result;
       },
     },
 

package/src/runtime/plugin-ops.ts

@@ -8,6 +8,7 @@ import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 import { loadPlugins, validateDependencies, sortByDependencies } from '../plugins/index.js';
+import { createPackRuntime } from '../domain-packs/pack-runtime.js';
 
 export function createPluginOps(runtime: AgentRuntime, opSink?: OpDefinition[]): OpDefinition[] {
   const { pluginRegistry, config } = runtime;
@@ -157,6 +158,7 @@ export function createPluginOps(runtime: AgentRuntime, opSink?: OpDefinition[]):
           if (!plugin) return { error: `Plugin not found: ${pluginId}` };
 
           const result = await pluginRegistry.activate(pluginId, {
+            packRuntime: createPackRuntime(runtime),
             runtime,
             manifest: plugin.manifest,
             directory: plugin.directory,
@@ -179,6 +181,7 @@ export function createPluginOps(runtime: AgentRuntime, opSink?: OpDefinition[]):
         const results = await Promise.all(
           pending.map(async (plugin) => {
             const activated = await pluginRegistry.activate(plugin.id, {
+              packRuntime: createPackRuntime(runtime),
               runtime,
               manifest: plugin.manifest,
               directory: plugin.directory,

package/src/runtime/session-briefing.ts

@@ -42,6 +42,20 @@ export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[]
         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 });

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

@@ -328,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++;