synabun 1.3.0 → 2.0.0-beta

package/mcp-server/src/tools/profile.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { text } from './response.js';
+import { VALID_GROUPS, getProfilePresets, persistRuntimeProfile, type ProfileRuntime } from '../services/profiles.js';
+import { reportRuntimeMcpProfile, type RuntimeMcpProfileReport } from '../services/neural-interface.js';
+
+export const profileSchema = {
+  action: z.enum(['get', 'set']).describe(
+    'get = inspect this runtime and its available presets. set = switch only this runtime to another profile and refresh the host tool list.'
+  ),
+  profile: z.string().optional().describe(
+    'Profile to switch to (required for "set"). Call get for current presets, choose the narrowest one that supplies the needed tools, or pass valid comma-separated groups.'
+  ),
+};
+
+export const profileDescription =
+  'Always-available MCP capability router. If a task needs a tool that is not currently listed, call action="get", then action="set" with the narrowest suitable profile and continue after the host refreshes its tools. Codex advertises the complete SynaBun catalog as deferred tools from turn start, so its profile is a focus selection and needs no reload. Do not claim a SynaBun capability is unavailable before trying this. A switch affects only the current sidepanel/loop/schedule runtime and never changes other sessions or the future-session default.';
+
+const ALWAYS_ON_TOOL_COUNT = 11;
+const GROUP_TOOL_ESTIMATES: Record<string, number> = {
+  git: 1,
+  image: 1,
+  whiteboard: 3,
+  card: 4,
+  tictactoe: 2,
+  browser: 20,
+  browser_twitter: 1,
+  browser_facebook: 1,
+  browser_tiktok: 4,
+  browser_whatsapp: 2,
+  browser_instagram: 5,
+  browser_linkedin: 8,
+  browser_bluesky: 15,
+  leonardo: 5,
+  discord: 8,
+  gsc: 30,
+  youtube: 11,
+  styleguide: 1,
+  morelogin: 1,
+  agents: 11,
+  computer: 4,
+};
+
+export async function handleProfile(runtime: ProfileRuntime, args: { action: string; profile?: string }) {
+  if (args.action === 'get') {
+    const { profile, activeGroups } = runtime.getActiveProfile();
+    const presets = Object.entries(getProfilePresets()).map(([name, groups]) => ({
+      name,
+      groups,
+      toolEstimate: `~${ALWAYS_ON_TOOL_COUNT + groups.reduce((sum, group) => sum + (GROUP_TOOL_ESTIMATES[group] || 0), 0)}`,
+    }));
+    return text(JSON.stringify({
+      currentProfile: profile,
+      activeGroups,
+      catalogMode: runtime.getCatalogMode(),
+      // Role-gated groups (agents) follow the role, not the profile.
+      role: runtime.getRole(),
+      presets,
+      validGroups: Array.from(VALID_GROUPS),
+    }, null, 2));
+  }
+
+  if (args.action === 'set') {
+    if (!args.profile) {
+      return text('Error: "profile" parameter is required for action "set". Call action="get" for the available presets or use valid comma-separated groups.');
+    }
+    let result;
+    try {
+      result = runtime.applyProfile(args.profile);
+    } catch (err) {
+      return text(`Error: ${err instanceof Error ? err.message : String(err)}. Call action="get" for valid presets and groups.`);
+    }
+    const runtimeStatePersisted = persistRuntimeProfile(result.profile);
+    const runtimeReport: RuntimeMcpProfileReport = await reportRuntimeMcpProfile(result.profile, {
+      catalogMode: result.catalogMode,
+    });
+    let hostRefresh: 'scheduled' | 'notification' | 'unavailable' | 'not-needed' = 'not-needed';
+    let toolListNotification: 'scheduled' | 'unavailable' | 'not-needed' = 'not-needed';
+    if (result.catalogMode === 'profiled') {
+      // Always queue one post-response MCP notification. Managed sidepanels
+      // may also perform a host-level reconnect. Queue this even when the
+      // requested profile already matches so an explicit retry can repair a
+      // stale/lost host catalog instead of becoming a silent no-op.
+      const notificationScheduled = runtime.scheduleProfileChangedNotification();
+      toolListNotification = notificationScheduled ? 'scheduled' : 'unavailable';
+      hostRefresh = runtimeReport.hostRefresh === 'scheduled'
+        ? 'scheduled'
+        : notificationScheduled ? 'notification' : 'unavailable';
+    } else {
+      // Codex snapshots deferred MCP schemas at turn start, so its SynaBun
+      // process advertises the complete deferred catalog from the beginning.
+      // Changing the focus profile updates runtime/UI state only; no tool-list
+      // mutation or global MCP reload is needed.
+      hostRefresh = 'not-needed';
+    }
+    return text(JSON.stringify({
+      switched: true,
+      changed: result.changed,
+      profile: result.profile,
+      enabled: result.enabled,
+      disabled: result.disabled,
+      totalTools: result.totalTools,
+      scope: 'current-runtime',
+      catalogMode: result.catalogMode,
+      runtimeStatePersisted,
+      runtimeStateReported: runtimeReport.reported,
+      hostRefresh,
+      toolListNotification,
+      ...(runtimeReport.runtimeKind ? { runtimeKind: runtimeReport.runtimeKind } : {}),
+      ...(runtimeReport.correlationId ? { refreshCorrelationId: runtimeReport.correlationId } : {}),
+      ...(runtimeReport.error ? { refreshReportError: runtimeReport.error } : {}),
+      note: result.catalogMode === 'deferred'
+        ? 'The Codex focus profile changed. Its complete SynaBun catalog was already available through deferred tools, so no MCP reload was needed.'
+        : hostRefresh === 'not-needed'
+          ? 'This runtime already uses the requested profile.'
+          : hostRefresh === 'unavailable'
+            ? 'The runtime profile changed, but the host refresh could not be scheduled. Retry the switch or use the sidepanel selector.'
+            : 'The runtime profile changed. The host tool refresh is queued; continue with the newly loaded tools.',
+    }, null, 2));
+  }
+
+  return text(`Unknown action "${args.action}". Use "get" or "set".`);
+}

package/mcp-server/src/tools/recall.ts

@@ -1,97 +1,15 @@
 import { z } from 'zod';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
-import { generateEmbedding } from '../services/local-embeddings.js';
-import { searchMemories, searchMemoriesFTS, updatePayload, searchSessionChunks } from '../services/sqlite.js';
+import { retrieveMemory, compactRecall } from '../services/memory-retrieval.js';
+import { touchMemories } from '../services/sqlite.js';
 import { validateCategory } from '../services/categories.js';
 import { coerceStringArray } from './utils.js';
 import type { MemoryPayload, SessionChunkPayload } from '../types.js';
 import { config, detectProject } from '../config.js';
 import { text } from './response.js';
 
-export function buildRecallSchema() {
-  return {
-    query: z.string().describe('What to search for, in natural language.'),
-    category: z
-      .string()
-      .optional()
-      .describe('Optional: filter by category name.'),
-    project: z
-      .string()
-      .optional()
-      .describe(
-        'Optional: filter by project. If omitted, searches all projects but boosts current project.'
-      ),
-    tags: coerceStringArray()
-      .optional()
-      .describe('Optional: filter by tags (any match).'),
-    limit: z
-      .coerce.number()
-      .min(1)
-      .max(20)
-      .optional()
-      .describe('Number of results (default 5).'),
-    min_importance: z
-      .coerce.number()
-      .min(1)
-      .max(10)
-      .optional()
-      .describe('Minimum importance threshold.'),
-    min_score: z
-      .coerce.number()
-      .min(0)
-      .max(1)
-      .optional()
-      .describe('Minimum similarity score 0-1 (default 0.3).'),
-    include_sessions: z
-      .boolean()
-      .optional()
-      .describe('Override session chunk search. Auto-triggers on temporal queries or sparse results. Set true to force, false to disable.'),
-    recency_boost: z
-      .boolean()
-      .optional()
-      .describe('Prioritize recent memories. Shifts scoring to favor recency over semantic similarity (14-day half-life, 55% recency weight). Ideal for session-start boot queries.'),
-  };
-}
-
-export const recallSchema = buildRecallSchema();
-
-export const recallDescription =
-  'Search your persistent memory for relevant information. Use this at the start of any task to check what you already know, or when you need context about past decisions, known issues, or architectural patterns.';
-
-function applyTimeDecay(
-  rawScore: number,
-  createdAt: string,
-  importance: number,
-  accessCount: number,
-  recencyBoost = false
-): number {
-  const ageInDays =
-    (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
-  const accessBoost = Math.min(0.1, accessCount * 0.01);
-
-  if (recencyBoost) {
-    // Recency-first scoring: 14-day half-life, recency dominates
-    const recencyMultiplier = Math.pow(0.5, ageInDays / 14);
-    return rawScore * 0.35 + recencyMultiplier * 0.55 + accessBoost;
-  }
-
-  // Default scoring: semantic similarity dominates, 90-day half-life
-  if (importance >= 8) return rawScore;
-  const recencyMultiplier = Math.pow(0.5, ageInDays / 90);
-  return rawScore * 0.7 + recencyMultiplier * 0.2 + accessBoost;
-}
-
-function formatAge(isoDate: string): string {
-  const diffMs = Date.now() - new Date(isoDate).getTime();
-  const days = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-  if (days === 0) return 'today';
-  if (days === 1) return '1 day ago';
-  if (days < 30) return `${days} days ago`;
-  const months = Math.floor(days / 30);
-  if (months === 1) return '1 month ago';
-  return `${months} months ago`;
-}
+// ── Recall defaults (must be defined before buildRecallSchema which runs at module level) ──
 
 interface RecallDefaults {
   limit: number;
@@ -117,7 +35,6 @@ function getRecallDefaults(): RecallDefaults {
     const data = JSON.parse(readFileSync(settingsPath, 'utf-8'));
     const d = data.recallDefaults;
     if (!d) {
-      // Legacy: only recallMaxChars exists
       return { ...RECALL_DEFAULTS, maxChars: data.recallMaxChars ?? 0 };
     }
     return {
@@ -133,191 +50,118 @@ function getRecallDefaults(): RecallDefaults {
   }
 }
 
-export async function handleRecall(args: {
-  query: string;
-  category?: string;
-  project?: string;
-  tags?: string[];
-  limit?: number;
-  min_importance?: number;
-  min_score?: number;
-  include_sessions?: boolean;
-  recency_boost?: boolean;
-}) {
-  const defaults = getRecallDefaults();
-  const query = args.query;
-  const category = args.category;
-  const project = args.project;
-  const tags = args.tags;
-  const limit = args.limit ?? defaults.limit;
-  const minImportance = args.min_importance ?? (defaults.minImportance > 0 ? defaults.minImportance : undefined);
-  const minScore = args.min_score ?? defaults.minScore;
-  const includeSessionsExplicit = args.include_sessions ??
-    (defaults.includeSessions === 'always' ? true : defaults.includeSessions === 'never' ? false : undefined);
-  const recencyBoost = args.recency_boost ?? defaults.recencyBoost;
-
-  if (category) {
-    const catCheck = validateCategory(category);
-    if (!catCheck.valid) {
-      return text(catCheck.error!);
-    }
-  }
-
-  const vector = await generateEmbedding(query);
+// ── Schema builder ──
 
-  const must: Record<string, unknown>[] = [];
-  if (category) must.push({ key: 'category', match: { value: category } });
-  if (project) must.push({ key: 'project', match: { value: project } });
-  if (tags && tags.length > 0) {
-    for (const tag of tags) {
-      must.push({ key: 'tags', match: { value: tag } });
-    }
-  }
-  if (minImportance) {
-    must.push({ key: 'importance', range: { gte: minImportance } });
-  }
-
-  const filter = must.length > 0 ? { must } : undefined;
-  // Use a lower raw threshold for the DB query — time decay, importance,
-  // and project boosts can lift borderline results well above minScore.
-  // The actual minScore filter is applied after adjustments below.
-  const rawThreshold = Math.min(minScore, minScore * 0.5);
-  const results = await searchMemories(vector, limit * 2, filter, rawThreshold);
-
-  const currentProject = detectProject();
-  const scored = results
-    .map((r) => {
-      const payload = r.payload as unknown as MemoryPayload;
-      let adjustedScore = applyTimeDecay(
-        r.score,
-        payload.created_at,
-        payload.importance,
-        payload.access_count,
-        recencyBoost
-      );
-      if (!project && payload.project === currentProject) {
-        adjustedScore *= 1.2;
-      }
-      return { id: r.id as string, score: adjustedScore, payload };
-    })
-    .filter((r) => r.score >= minScore)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, limit);
-
-  // FTS5 keyword fallback — when vector results are weak, supplement with
-  // full-text search to catch exact identifiers, error codes, proper nouns
-  const FTS_TRIGGER_SCORE = 0.45;
-  const vectorWeak = scored.length === 0 ||
-    (scored.length < limit && scored[0]?.score < FTS_TRIGGER_SCORE);
+export function buildRecallSchema() {
+  const defaults = getRecallDefaults();
+  const sessionDesc = defaults.includeSessions === 'auto'
+    ? 'Auto-triggers on temporal queries or sparse results.'
+    : `Default: ${defaults.includeSessions}.`;
+  // All configurable fields use .optional() — NOT .default() — so Zod never
+  // injects stale schema defaults.  handleRecall() reads fresh values from
+  // display-settings.json at runtime via getRecallDefaults() and applies them
+  // with the ?? operator when the AI omits a parameter.
 
-  if (vectorWeak) {
-    try {
-      const existingIds = new Set(scored.map(r => r.id));
-      const ftsResults = await searchMemoriesFTS(query, limit, filter, existingIds);
-      for (const fts of ftsResults) {
-        if (scored.length >= limit) break;
-        scored.push(fts);
-      }
-      // Re-sort after merge
-      scored.sort((a, b) => b.score - a.score);
-    } catch {
-      // FTS fallback failure is non-fatal
-    }
-  }
+  const limitField = z.coerce.number().min(1).max(20).optional()
+    .describe(`Number of results. User configured: ${defaults.limit}. OMIT this parameter to respect the user's setting. Only override if the user explicitly asks for a different count.`);
 
-  // Update access tracking (fire-and-forget)
-  const now = new Date().toISOString();
-  for (const result of scored) {
-    updatePayload(result.id, {
-      accessed_at: now,
-      access_count: result.payload.access_count + 1,
-    }).catch(() => {});
-  }
+  const minImpField = defaults.minImportance > 0
+    ? z.coerce.number().min(1).max(10).optional()
+        .describe(`Minimum importance threshold. User configured: ${defaults.minImportance}. OMIT to use configured setting.`)
+    : z.coerce.number().min(1).max(10).optional()
+        .describe('Minimum importance threshold.');
 
-  if (scored.length === 0) {
-    return text(`No memories found for "${query}"${category ? ` in category ${category}` : ''}${project ? ` for project ${project}` : ''}.`);
-  }
+  const minScoreField = z.coerce.number().min(0).max(1).optional()
+    .describe(`Minimum similarity score 0-1. User configured: ${defaults.minScore}. OMIT to use configured setting.`);
 
-  const maxChars = defaults.maxChars;
+  const sessionField = z.boolean().optional()
+    .describe(`Override session chunk search. ${sessionDesc} Set true to force, false to disable.`);
 
-  const lines = scored.map((r, i) => {
-    const p = r.payload;
-    const score = (r.score * 100).toFixed(0);
-    const tagStr = p.tags?.length ? ` [${p.tags.join(', ')}]` : '';
-    const sub = p.subcategory ? `/${p.subcategory}` : '';
-    const files = p.related_files?.length
-      ? `\n   Files: ${p.related_files.join(', ')}`
-      : '';
-    const displayContent = (maxChars > 0 && p.content.length > maxChars)
-      ? p.content.substring(0, maxChars) + '...'
-      : p.content;
-    return `${i + 1}. [${r.id}] (${score}% match, importance: ${p.importance}, ${formatAge(p.created_at)})\n   ${p.category}${sub} | ${p.project}${tagStr}\n   ${displayContent}${files}`;
-  });
+  const recencyField = z.boolean().optional()
+    .describe(`Prioritize recent memories. User configured: ${defaults.recencyBoost ? 'ON' : 'OFF'}. OMIT to use configured setting. Shifts scoring to favor recency over semantic similarity (14-day half-life, 55% recency weight). Ideal for session-start boot queries.`);
 
-  // Session chunk search — auto-trigger when useful, or explicit override
-  const shouldIncludeSessions = (() => {
-    // Explicit override takes priority
-    if (includeSessionsExplicit !== undefined) return includeSessionsExplicit;
-    // Temporal/process keywords → likely asking about past sessions
-    const q = query.toLowerCase();
-    const sessionKeywords = [
-      'yesterday', 'last session', 'last time', 'remember when',
-      'how did we', 'what did we', 'earlier today', 'previous session',
-      'conversation about', 'we discussed', 'we worked on', 'we talked about',
-      'that session', 'that conversation', 'the other day', 'last week',
-      'before', 'recently', 'a while ago', 'few days ago',
-    ];
-    if (sessionKeywords.some(kw => q.includes(kw))) return true;
-    // Sparse/weak memory results → widen the net
-    if (scored.length < 3) return true;
-    if (scored.length > 0 && scored[0].score < 0.45) return true;
-    return false;
-  })();
+  return {
+    query: z.string().describe('What to search for, in natural language.'),
+    category: z
+      .string()
+      .optional()
+      .describe('Optional: filter by category name.'),
+    project: z
+      .string()
+      .optional()
+      .describe(
+        'Optional: filter by project. If omitted, searches all projects but boosts current project.'
+      ),
+    tags: coerceStringArray()
+      .optional()
+      .describe('Optional: filter by tags (any match).'),
+    limit: limitField,
+    min_importance: minImpField,
+    min_score: minScoreField,
+    include_sessions: sessionField,
+    recency_boost: recencyField,
+    format: z.enum(['legacy', 'compact']).optional().describe('Optional compact, budgeted excerpts. Default preserves full legacy output.'),
+    token_budget: z.coerce.number().int().min(100).max(16000).optional().describe('Total estimated output tokens for compact format; default 1500.'),
+    tag_match: z.enum(['any','all']).optional().describe('Match any tag (default) or require every tag.'),
+    scope: z.enum(['all','project']).optional().describe('Project requires an explicit project or caller context; never widens the search.'),
+    after: z.string().datetime({ offset: true }).optional().describe('Include records created at or after this ISO timestamp.'),
+    before: z.string().datetime({ offset: true }).optional().describe('Include records created at or before this ISO timestamp.'),
+    explain: z.boolean().optional().describe('Include retrieval reasons in compact output.'),
+    rerank: z.boolean().optional().describe('Judge the shortlist for relevance after retrieval and reorder it. Slower — worth it when the query is subtle and the top hits look interchangeable.'),
+  };
+}
 
-  let sessionLines: string[] = [];
-  if (shouldIncludeSessions) {
-    try {
-      const sessionFilter: Record<string, unknown> = {};
-      if (project) {
-        sessionFilter.must = [{ key: 'project', match: { value: project } }];
-      }
-      const sessionLimit = Math.max(3, Math.floor(limit / 2));
-      const sessionResults = await searchSessionChunks(vector, sessionLimit * 2, Object.keys(sessionFilter).length > 0 ? sessionFilter : undefined, rawThreshold);
+export const recallSchema = buildRecallSchema();
 
-      // Deduplicate: skip chunks whose dedup_memory_id matches a returned memory
-      const memoryIds = new Set(scored.map((r) => r.id));
-      const filteredSessions = sessionResults.filter((r) => {
-        const payload = r.payload as unknown as SessionChunkPayload;
-        return !payload.dedup_memory_id || !memoryIds.has(payload.dedup_memory_id);
-      }).slice(0, sessionLimit);
+export const recallDescription =
+  'Search your persistent memory for relevant information. Use this at the start of any task to check what you already know, or when you need context about past decisions, known issues, or architectural patterns. Prefer format="compact" for discovery; use memories action="get" for full originals.';
 
-      sessionLines = filteredSessions.map((r, i) => {
-        const p = r.payload as unknown as SessionChunkPayload;
-        const score = (r.score * 100).toFixed(0);
-        const timeRange = p.start_timestamp && p.end_timestamp
-          ? `${new Date(p.start_timestamp).toISOString().slice(0, 16)} - ${new Date(p.end_timestamp).toISOString().slice(11, 16)}`
-          : 'unknown time';
-        const toolStr = p.tools_used?.length ? `Tools: ${p.tools_used.join(', ')}` : '';
-        const fileStr = p.files_modified?.length ? `Files: ${p.files_modified.join(', ')}` : '';
-        const linkedMems = p.related_memory_ids?.length ? `Linked memories: ${p.related_memory_ids.join(', ')}` : '';
-        const details = [toolStr, fileStr, linkedMems].filter(Boolean).join(' | ');
-        return `SESSION: [${r.id}] (${score}% match, ${timeRange}, branch: ${p.git_branch || 'unknown'})\n   Session: ${p.session_id} | Chunk ${p.chunk_index + 1} | ${p.project}\n   ${p.summary}\n   ${details}`;
-      });
-    } catch {
-      // Session search failure is non-fatal
-    }
-  }
+function formatAge(isoDate: string): string {
+  const diffMs = Date.now() - new Date(isoDate).getTime();
+  const days = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+  if (days === 0) return 'today';
+  if (days === 1) return '1 day ago';
+  if (days < 30) return `${days} days ago`;
+  const months = Math.floor(days / 30);
+  if (months === 1) return '1 month ago';
+  return `${months} months ago`;
+}
 
-  const allLines = [...lines];
-  if (sessionLines.length > 0) {
-    allLines.push('', '--- Session Context ---');
-    allLines.push(...sessionLines);
+export async function handleRecall(args: {
+  query: string; category?: string; project?: string; tags?: string[]; limit?: number;
+  min_importance?: number; min_score?: number; include_sessions?: boolean; recency_boost?: boolean;
+  format?: 'legacy'|'compact'; token_budget?: number; tag_match?: 'any'|'all';
+  scope?: 'all'|'project'; after?: string; before?: string; explain?: boolean; rerank?: boolean;
+}) {
+  const defaults = getRecallDefaults();
+  if (args.category) {
+    const check = validateCategory(args.category);
+    if (!check.valid) return text(check.error!);
   }
-
-  const totalCount = scored.length + sessionLines.length;
-  const label = sessionLines.length > 0
-    ? `Found ${scored.length} memories and ${sessionLines.length} session chunks`
-    : `Found ${scored.length} memories`;
-
-  return text(`${label} for "${query}":\n\n${allLines.join('\n\n')}`);
+  if (args.after && args.before && args.after > args.before) return text('after must not be later than before.');
+  try {
+    const currentProject = detectProject();
+    const result = await retrieveMemory({
+      ...args, currentProject, limit: args.limit ?? defaults.limit,
+      judgeContext: { origin: 'tool', project: args.project ?? currentProject },
+      min_score: args.min_score ?? defaults.minScore,
+      min_importance: args.min_importance ?? (defaults.minImportance || undefined),
+      include_sessions: args.include_sessions ?? (defaults.includeSessions === 'auto' ? undefined : defaults.includeSessions === 'always'),
+      recency_boost: args.recency_boost ?? defaults.recencyBoost,
+    });
+    await touchMemories(result.results.filter(r=>r.type === 'memory').map(r=>r.id),new Date().toISOString());
+    if (args.format === 'compact' || args.token_budget !== undefined) return text(compactRecall(result,args.query,args.token_budget ?? 1500,args.explain));
+    if (!result.results.length) return text(`No memories found for "${args.query}"${args.category ? ` in category ${args.category}` : ''}${args.project ? ` for project ${args.project}` : ''}.${result.degraded.length ? ' '+result.degraded.join(' ') : ''}`);
+    const memories = result.results.filter(r=>r.type === 'memory');
+    const sessions = result.results.filter(r=>r.type === 'session');
+    const lines = memories.map((r,i)=>{
+      const p = r.payload;
+      const content = defaults.maxChars > 0 && p.content.length > defaults.maxChars ? p.content.slice(0,defaults.maxChars)+'...' : p.content;
+      const rank = result.engine === 'hybrid' ? `relevance: ${r.score.toFixed(3)}` : `${(r.score*100).toFixed(0)}% match`;
+      return `${i+1}. [${r.id}] (${rank}, importance: ${p.importance}, ${formatAge(p.created_at)})\n   ${p.category}${p.subcategory ? '/'+p.subcategory : ''} | ${p.project} | source: ${p.source}\n   Tags: ${p.tags?.join(', ') || 'none'}\n   ${content}\n   Files: ${p.related_files?.join(', ') || 'none'}${r.flags.length ? '\n   Status: '+r.flags.join(', ') : ''}`;
+    });
+    if (sessions.length) lines.push('--- Session Context ---',...sessions.map(r=>`SESSION: [${r.id}] (${result.engine === 'hybrid' ? 'relevance: '+r.score.toFixed(3) : (r.score*100).toFixed(0)+'% match'}, ${r.created_at}, branch: ${r.payload.git_branch || 'unknown'})\n   Session: ${r.payload.session_id} | Chunk ${r.payload.chunk_index+1} | ${r.project}\n   ${r.payload.summary || r.content}\n   Tools: ${r.payload.tools_used?.join(', ') || 'none'} | Files: ${r.payload.files_modified?.join(', ') || 'none'}`));
+    const label = sessions.length ? `Found ${memories.length} memories and ${sessions.length} session chunks` : `Found ${memories.length} memories`;
+    return text(`${label} for "${args.query}":\n\n${lines.join('\n\n')}${result.degraded.length ? '\n\n'+result.degraded.join(' ') : ''}`);
+  } catch (error) { return { ...text((error as Error).message), isError: true }; }
 }