@chendpoc/pi-memory 0.1.12 → 0.2.0

package/src/adapters/piComplete.ts

@@ -1,233 +0,0 @@
-import { complete, getEnvApiKey, getModels } from "@earendil-works/pi-ai/compat";
-import type { Api, Model, ProviderEnv, ToolCall } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-
-import {
-  COMPILE_MEMORY_INTENTS_PARAMETERS,
-  MEMORY_HELPER_TOOL_NAME,
-  type CompileMemoryIntentsResult,
-  type MemoryHelperLLM,
-} from "../preflight/detectIntents.js";
-import type { LLMClient } from "../trainer/llmExtractor.js";
-
-export const DEFAULT_HELPER_PROVIDER = "deepseek";
-export const DEFAULT_HELPER_MODEL = "deepseek-v4-flash";
-
-const CompileMemoryIntentsParams = Type.Unsafe(COMPILE_MEMORY_INTENTS_PARAMETERS);
-
-export function parseModelSpec(
-  spec: string | boolean | undefined,
-  defaultProvider = DEFAULT_HELPER_PROVIDER,
-  defaultModelId = DEFAULT_HELPER_MODEL,
-): { provider: string; modelId: string } {
-  if (typeof spec !== "string" || !spec.trim()) {
-    return { provider: defaultProvider, modelId: defaultModelId };
-  }
-  const trimmed = spec.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash === -1) {
-    return { provider: defaultProvider, modelId: trimmed };
-  }
-  return {
-    provider: trimmed.slice(0, slash),
-    modelId: trimmed.slice(slash + 1),
-  };
-}
-
-async function resolveModelAuth(
-  ctx: ExtensionContext,
-  provider: string,
-  modelId: string,
-): Promise<{ model: Model<Api>; apiKey: string; headers?: Record<string, string>; env?: ProviderEnv } | null> {
-  const model = ctx.modelRegistry.find(provider, modelId);
-  if (!model) return null;
-
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok || !auth.apiKey) return null;
-
-  return {
-    model,
-    apiKey: auth.apiKey,
-    headers: auth.headers,
-    env: auth.env,
-  };
-}
-
-function extractTextFromResponse(content: Array<{ type: string; text?: string }>): string {
-  return content
-    .filter((block): block is { type: "text"; text: string } => block.type === "text")
-    .map((block) => block.text)
-    .join("\n");
-}
-
-function findToolCall(
-  content: Array<{ type: string; name?: string; arguments?: Record<string, unknown> }>,
-  toolName: string,
-): ToolCall | null {
-  for (const block of content) {
-    if (block.type === "toolCall" && block.name === toolName && block.arguments) {
-      return block as ToolCall;
-    }
-  }
-  return null;
-}
-
-function buildMemoryHelperLLM(
-  resolved: NonNullable<Awaited<ReturnType<typeof resolveModelAuth>>>,
-): MemoryHelperLLM {
-  return {
-    async compileIntents(text: string, signal?: AbortSignal): Promise<CompileMemoryIntentsResult> {
-      const response = await complete(
-        resolved.model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [
-                {
-                  type: "text",
-                  text: `Analyze whether the user message requires recalling private episodic memory.\n\n<message>\n${text}\n</message>`,
-                },
-              ],
-              timestamp: Date.now(),
-            },
-          ],
-          tools: [
-            {
-              name: MEMORY_HELPER_TOOL_NAME,
-              description:
-                "Decide whether to recall private episodic memory and compile structured query intents.",
-              parameters: CompileMemoryIntentsParams,
-            },
-          ],
-        },
-        {
-          apiKey: resolved.apiKey,
-          headers: resolved.headers,
-          env: resolved.env,
-          signal,
-          toolChoice: { type: "tool", name: MEMORY_HELPER_TOOL_NAME },
-        },
-      );
-
-      const toolCall = findToolCall(response.content, MEMORY_HELPER_TOOL_NAME);
-      if (toolCall?.arguments) {
-        return toolCall.arguments as CompileMemoryIntentsResult;
-      }
-
-      const raw = extractTextFromResponse(response.content);
-      if (!raw.trim()) {
-        return { should_recall: false, intents: [] };
-      }
-      return JSON.parse(raw) as CompileMemoryIntentsResult;
-    },
-  };
-}
-
-/** Resolve helper LLM when model + auth are available; otherwise null (regex-only preflight). */
-export async function resolveMemoryHelperLLM(
-  ctx: ExtensionContext,
-  modelSpec: string | boolean | undefined,
-): Promise<MemoryHelperLLM | null> {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-  const resolved = await resolveModelAuth(ctx, provider, modelId);
-  if (!resolved) return null;
-  return buildMemoryHelperLLM(resolved);
-}
-
-/** @alias resolveMemoryHelperLLM */
-export const createMemoryHelperLLM = resolveMemoryHelperLLM;
-
-export function createPiLLMClient(
-  ctx: ExtensionContext,
-  modelSpec: string | boolean | undefined,
-): LLMClient | null {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-
-  return {
-    async complete(prompt: string): Promise<string> {
-      const resolved = await resolveModelAuth(ctx, provider, modelId);
-      if (!resolved) {
-        throw new Error(`LLM model not available: ${provider}/${modelId}`);
-      }
-
-      const response = await complete(
-        resolved.model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: prompt }],
-              timestamp: Date.now(),
-            },
-          ],
-        },
-        {
-          apiKey: resolved.apiKey,
-          headers: resolved.headers,
-          env: resolved.env,
-          maxTokens: 8192,
-        },
-      );
-
-      const text = extractTextFromResponse(response.content);
-      if (!text.trim()) {
-        throw new Error("LLM response was empty");
-      }
-      return text;
-    },
-  };
-}
-
-/** Standalone LLM client for CLI usage without ExtensionContext. */
-export function createStandaloneLLMClient(
-  modelSpec?: string,
-  env: NodeJS.ProcessEnv = process.env,
-): LLMClient {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-  const providerEnv = toProviderEnv(env);
-  const model = getModels(provider as Parameters<typeof getModels>[0]).find((m) => m.id === modelId);
-  if (!model) {
-    throw new Error(`Model not found: ${provider}/${modelId}`);
-  }
-
-  const apiKey = getEnvApiKey(provider, providerEnv);
-  if (!apiKey) {
-    throw new Error(`No API key for ${provider} — set the provider env var or use regex extractor`);
-  }
-
-  return {
-    async complete(prompt: string): Promise<string> {
-      const response = await complete(
-        model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: prompt }],
-              timestamp: Date.now(),
-            },
-          ],
-        },
-        {
-          apiKey,
-          maxTokens: 8192,
-          env: providerEnv,
-        },
-      );
-
-      const text = extractTextFromResponse(response.content);
-      if (!text.trim()) {
-        throw new Error("LLM response was empty");
-      }
-      return text;
-    },
-  };
-}
-
-function toProviderEnv(env: NodeJS.ProcessEnv): ProviderEnv {
-  return Object.fromEntries(
-    Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined),
-  );
-}

package/src/bundle/install.ts

@@ -1,206 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import type { BundleManifest } from "../sidecar/bundle.js";
-
-export interface InstallBundleOptions {
-  bundleRoot: string;
-  sourceDir: string;
-  /** Number of old bundles to keep after install (default 3). */
-  retain?: number;
-}
-
-export interface InstallBundleResult {
-  bundle_ts: string;
-  bundle_version: string;
-  installed_dir: string;
-  files_copied: number;
-}
-
-/**
- * Enforces [0.4.0, 0.7.0) — producers guarantee additive minor bumps in this
- * range; breaking schema changes move to 0.7.0+ to trip this gate.
- * Ported from Kocoro internal/memory/bundle.go versionInRange.
- */
-export function versionInRange(v: string): boolean {
-  const parts = v.split(".");
-  if (parts.length !== 3) return false;
-  const [maj, min, pat] = parts.map(Number);
-  if (maj !== 0 || isNaN(min!) || isNaN(pat!)) return false;
-  if (min! < 4 || min! >= 7) return false;
-  return pat! >= 0;
-}
-
-/**
- * Keep the newest `keep` bundle dirs plus the current symlink target.
- * Best-effort — failures are silently ignored.
- * Ported from Kocoro internal/memory/bundle.go Puller.retain.
- */
-export async function retainBundles(bundleRoot: string, keep: number): Promise<void> {
-  const bundlesDir = path.join(bundleRoot, "bundles");
-  let names: string[];
-  try {
-    names = await fs.readdir(bundlesDir);
-  } catch {
-    return;
-  }
-  const dirs: string[] = [];
-  for (const name of names) {
-    try {
-      const st = await fs.stat(path.join(bundlesDir, name));
-      if (st.isDirectory()) dirs.push(name);
-    } catch { /* skip unreadable */ }
-  }
-  dirs.sort().reverse();
-  if (dirs.length <= keep) return;
-
-  let currentTarget = "";
-  try {
-    const target = await fs.readlink(path.join(bundleRoot, "current"));
-    currentTarget = path.basename(target);
-  } catch { /* no current pointer */ }
-
-  const keepSet = new Set<string>();
-  for (let i = 0; i < Math.min(keep, dirs.length); i++) {
-    keepSet.add(dirs[i]!);
-  }
-  if (currentTarget) keepSet.add(currentTarget);
-
-  for (const d of dirs) {
-    if (!keepSet.has(d)) {
-      await fs.rm(path.join(bundlesDir, d), { recursive: true, force: true }).catch(() => {});
-    }
-  }
-}
-
-/**
- * Path sandboxing rules from Kocoro bundle.go validateManifestPath (§4.2).
- */
-export function validateManifestPath(rel: string, stagingDir: string): string | null {
-  if (!rel) return "empty path";
-  if (rel.includes("\0")) return "null byte in path";
-  if (path.isAbsolute(rel)) return "absolute path";
-  const cleaned = path.normalize(rel);
-  if (
-    cleaned === ".." ||
-    cleaned.startsWith(`..${path.sep}`) ||
-    cleaned.includes(`${path.sep}..`)
-  ) {
-    return "contains parent traversal";
-  }
-  const abs = path.join(stagingDir, cleaned);
-  const cleanedAbs = path.normalize(abs);
-  const prefix = path.normalize(stagingDir) + path.sep;
-  if (!cleanedAbs.startsWith(prefix)) {
-    return "escapes staging dir";
-  }
-  return null;
-}
-
-async function sha256File(filePath: string): Promise<string> {
-  const data = await fs.readFile(filePath);
-  return createHash("sha256").update(data).digest("hex");
-}
-
-/**
- * Points <bundleRoot>/current at finalDir. On Windows uses a directory junction
- * (unprivileged, no Developer Mode needed — os.Symlink would fail with
- * ERROR_PRIVILEGE_NOT_HELD on stock hosts). On POSIX uses atomic tmp-symlink +
- * rename. Ported from Kocoro bundle_link_{unix,windows}.go.
- */
-async function swapCurrent(bundleRoot: string, finalDir: string): Promise<void> {
-  const currentLink = path.join(bundleRoot, "current");
-
-  if (process.platform === "win32") {
-    try { await fs.rm(currentLink, { recursive: true, force: true }); } catch { /* absent */ }
-    await fs.symlink(finalDir, currentLink, "junction");
-    return;
-  }
-
-  const tmpLink = path.join(bundleRoot, "current.tmp");
-  try { await fs.unlink(tmpLink); } catch { /* absent */ }
-  await fs.symlink(finalDir, tmpLink);
-  await fs.rename(tmpLink, currentLink);
-}
-
-/**
- * Install a local bundle directory into bundleRoot (staging → bundles/<ts> → current).
- * Verifies per-file sha256 when manifest lists hashes.
- */
-export async function installBundle(
-  opts: InstallBundleOptions,
-): Promise<InstallBundleResult> {
-  const sourceDir = path.resolve(opts.sourceDir);
-  const bundleRoot = path.resolve(opts.bundleRoot);
-
-  const manifestPath = path.join(sourceDir, "manifest.json");
-  const raw = await fs.readFile(manifestPath, "utf8");
-  const manifest = JSON.parse(raw) as BundleManifest;
-
-  if (!manifest.bundle_ts?.trim()) {
-    throw new Error("manifest missing bundle_ts");
-  }
-  if (!versionInRange(manifest.bundle_version ?? "")) {
-    throw new Error(
-      `bundle_version "${manifest.bundle_version}" outside supported range [0.4.0, 0.7.0)`,
-    );
-  }
-
-  await fs.mkdir(bundleRoot, { recursive: true, mode: 0o700 });
-
-  const staging = path.join(bundleRoot, "staging", manifest.bundle_ts);
-  await fs.rm(staging, { recursive: true, force: true });
-  await fs.mkdir(staging, { recursive: true, mode: 0o700 });
-
-  let filesCopied = 0;
-  for (const f of manifest.files ?? []) {
-    const err = validateManifestPath(f.path, staging);
-    if (err) {
-      await fs.rm(staging, { recursive: true, force: true });
-      throw new Error(`unsafe manifest path ${f.path}: ${err}`);
-    }
-    const src = path.join(sourceDir, path.normalize(f.path));
-    const dest = path.join(staging, path.normalize(f.path));
-    await fs.mkdir(path.dirname(dest), { recursive: true, mode: 0o700 });
-    await fs.copyFile(src, dest, fs.constants.COPYFILE_EXCL).catch(async () => {
-      await fs.copyFile(src, dest);
-    });
-
-    if (f.sha256) {
-      const got = await sha256File(dest);
-      if (got !== f.sha256) {
-        await fs.rm(staging, { recursive: true, force: true });
-        throw new Error(`sha256 mismatch on ${f.path}: got ${got} want ${f.sha256}`);
-      }
-    }
-    filesCopied++;
-  }
-
-  // Copy manifest itself if not listed in files[]
-  const manifestDest = path.join(staging, "manifest.json");
-  try {
-    await fs.access(manifestDest);
-  } catch {
-    await fs.copyFile(manifestPath, manifestDest);
-  }
-
-  const bundlesDir = path.join(bundleRoot, "bundles");
-  await fs.mkdir(bundlesDir, { recursive: true, mode: 0o700 });
-  const finalDir = path.join(bundlesDir, manifest.bundle_ts);
-  await fs.rm(finalDir, { recursive: true, force: true });
-  await fs.rename(staging, finalDir);
-  await swapCurrent(bundleRoot, finalDir);
-
-  const keep = opts.retain ?? 3;
-  if (keep > 0) {
-    await retainBundles(bundleRoot, keep);
-  }
-
-  return {
-    bundle_ts: manifest.bundle_ts,
-    bundle_version: manifest.bundle_version,
-    installed_dir: finalDir,
-    files_copied: filesCopied,
-  };
-}

package/src/cache/memoryCaches.ts

@@ -1,72 +0,0 @@
-import { LRUCache } from "lru-cache";
-import type { QueryIntent } from "../types.js";
-import type { RankedResult } from "../fallback/llmRerank.js";
-import type { SessionSearchHit } from "../fallback/sessionSearch.js";
-
-const INTENT_TTL_MS = 15 * 60_000;
-const RERANK_TTL_MS = 15 * 60_000;
-const NEGATIVE_TTL_MS = 60_000;
-
-/**
- * In-process LRU + TTL caches for pi-memory.
- *
- * - intentCache  : helper-LLM compile_memory_intents results, keyed by
- *                  normalised query text. TTL 15 min, LRU 128 entries.
- * - rerankCache  : LLM rerank results, keyed by query + hit fingerprint.
- *                  TTL 15 min, LRU 256 entries.
- * - negativeCache: queries that recently returned no usable context.
- *                  TTL 60 s, max 512 entries.
- *
- * All three caches must be invalidated together (`invalidateMemoryCaches()`)
- * after bundle reload so stale negative entries never block fresh graph data.
- */
-export const intentCache = new LRUCache<string, QueryIntent[]>({
-  max: 128,
-  ttl: INTENT_TTL_MS,
-});
-
-export const rerankCache = new LRUCache<string, RankedResult[]>({
-  max: 256,
-  ttl: RERANK_TTL_MS,
-});
-
-export const negativeCache = new LRUCache<string, true>({
-  max: 512,
-  ttl: NEGATIVE_TTL_MS,
-});
-
-function normalizeQuery(query: string): string {
-  return query.trim();
-}
-
-export function cacheKeyForIntents(query: string): string {
-  return normalizeQuery(query);
-}
-
-/**
- * Rerank cache key combines the query with a fingerprint of the hit set so
- * different FTS results for the same query get their own entry.
- */
-export function cacheKeyForRerank(query: string, hits: SessionSearchHit[]): string {
-  const hitIds = hits.map((h) => `${h.session_id}:${h.msg_index}`).join("|");
-  return `${normalizeQuery(query)}|${hitIds}`;
-}
-
-export function isNegativeCached(query: string): boolean {
-  return negativeCache.has(cacheKeyForIntents(query));
-}
-
-export function setNegativeCache(query: string): void {
-  negativeCache.set(cacheKeyForIntents(query), true);
-}
-
-export function deleteNegativeCache(query: string): void {
-  negativeCache.delete(cacheKeyForIntents(query));
-}
-
-/** Clear all three caches. Call after bundle reload or session shutdown. */
-export function invalidateMemoryCaches(): void {
-  intentCache.clear();
-  rerankCache.clear();
-  negativeCache.clear();
-}

package/src/config.ts

@@ -1,92 +0,0 @@
-import path from "node:path";
-
-import {
-  defaultBundleRoot,
-  defaultPiHome,
-  defaultSessionsDir,
-  defaultSocketPath,
-  expandPath,
-} from "./paths.js";
-
-export type MemoryProvider = "disabled" | "local" | "cloud";
-
-export type ExtractorType = "regex" | "llm";
-
-export interface TrainerConfig {
-  /** Which extractor to use (default "regex"). */
-  extractor: ExtractorType;
-  /** How many turns per LLM call when extractor is "llm" (default 10). */
-  llm_batch_size: number;
-  /** Auto-train interval: "1h"|"6h"|"12h"|"24h"|null (default null — disabled). */
-  auto_interval: string | null;
-}
-
-export interface MemoryConfig {
-  provider: MemoryProvider;
-  tlmPath: string;
-  socketPath: string;
-  bundleRoot: string;
-  sidecarReadyTimeoutMs: number;
-  queryTimeoutMs: number;
-  clientRequestTimeoutMs: number;
-  sessionsDir: string;
-  memoryMdPaths: string[];
-  trainer: TrainerConfig;
-}
-
-export const defaultTrainerConfig: TrainerConfig = {
-  extractor: "regex",
-  llm_batch_size: 10,
-  auto_interval: null,
-};
-
-export function defaultMemoryConfig(
-  overrides: Partial<MemoryConfig> = {},
-): MemoryConfig {
-  const { trainer: trainerOverrides, ...rest } = overrides;
-  return {
-    provider: "local",
-    tlmPath: "tlm",
-    socketPath: defaultSocketPath(),
-    bundleRoot: defaultBundleRoot(),
-    sidecarReadyTimeoutMs: 15_000,
-    queryTimeoutMs: 2_000,
-    clientRequestTimeoutMs: 5_000,
-    sessionsDir: defaultSessionsDir(),
-    memoryMdPaths: [path.join(defaultPiHome(), "MEMORY.md")],
-    trainer: { ...defaultTrainerConfig, ...trainerOverrides },
-    ...rest,
-  };
-}
-
-/** Normalize user-supplied paths after JSON/env load. */
-export function normalizeMemoryConfig(
-  raw: Partial<MemoryConfig> & Record<string, unknown>,
-): MemoryConfig {
-  const base = defaultMemoryConfig();
-  const rawTrainer = (raw.trainer ?? {}) as Partial<TrainerConfig>;
-  return {
-    provider: (raw.provider as MemoryProvider) ?? base.provider,
-    tlmPath: expandPath(String(raw.tlmPath ?? base.tlmPath)),
-    socketPath: expandPath(String(raw.socketPath ?? base.socketPath)),
-    bundleRoot: expandPath(String(raw.bundleRoot ?? base.bundleRoot)),
-    sidecarReadyTimeoutMs: Number(
-      raw.sidecarReadyTimeoutMs ?? base.sidecarReadyTimeoutMs,
-    ),
-    queryTimeoutMs: Number(raw.queryTimeoutMs ?? base.queryTimeoutMs),
-    clientRequestTimeoutMs: Number(
-      raw.clientRequestTimeoutMs ?? base.clientRequestTimeoutMs,
-    ),
-    sessionsDir: expandPath(String(raw.sessionsDir ?? base.sessionsDir)),
-    memoryMdPaths: Array.isArray(raw.memoryMdPaths)
-      ? raw.memoryMdPaths.map((p) => expandPath(String(p)))
-      : base.memoryMdPaths,
-    trainer: {
-      extractor: (rawTrainer.extractor as ExtractorType) ?? base.trainer.extractor,
-      llm_batch_size: Number(rawTrainer.llm_batch_size ?? base.trainer.llm_batch_size),
-      auto_interval: rawTrainer.auto_interval !== undefined
-        ? rawTrainer.auto_interval
-        : base.trainer.auto_interval,
-    },
-  };
-}

package/src/errclass.ts

@@ -1,37 +0,0 @@
-import { errorSubCode, type ResponseEnvelope } from "./types.js";
-
-export type ErrorClass = "ok" | "retryable" | "permanent" | "unavailable";
-
-export const ErrTransport = new Error("memory: transport failure");
-
-export function classifyTransportError(err: unknown): ErrorClass {
-  return err == null ? "ok" : "unavailable";
-}
-
-/** Maps HTTP status + envelope → error class (Kocoro memory/errclass.go). */
-export function classifyHTTP(
-  status: number,
-  env: ResponseEnvelope | null,
-): ErrorClass {
-  if (status >= 200 && status < 300) return "ok";
-  const sub = env?.error ? errorSubCode(env.error) : "";
-  const code = env?.error?.code ?? "";
-  switch (status) {
-    case 400:
-      return "permanent";
-    case 401:
-    case 403:
-      return "permanent";
-    case 409:
-      return "retryable";
-    case 422:
-      return "permanent";
-    case 503:
-      if (code === "not_ready" || sub === "not_ready") return "unavailable";
-      return "permanent";
-    case 500:
-      return "retryable";
-    default:
-      return "retryable";
-  }
-}

package/src/extension.ts

@@ -1,23 +0,0 @@
-/**
- * @deprecated Use `@chendpoc/pi-memory/extension` (pi-extension.ts) with real ExtensionAPI.
- * Re-exports the Pi extension entry for backward compatibility.
- */
-export { default, default as piMemoryExtension, getSharedMemoryService } from "./pi-extension.js";
-export type { BeforeTurnHook, MemoryHelperLLM } from "./preflight/hook.js";
-export { createBeforeTurnHook } from "./preflight/hook.js";
-
-/** @deprecated Stub types kept for programmatic callers migrating off the old API. */
-export interface PiExtensionAPI {
-  config?: Record<string, unknown>;
-  registerTool(tool: PiAgentTool): void;
-  onBeforeTurn?(hook: import("./preflight/hook.js").BeforeTurnHook): void;
-  onUnload?(fn: () => void | Promise<void>): void;
-}
-
-/** @deprecated */
-export interface PiAgentTool {
-  name: string;
-  description: string;
-  parameters: Record<string, unknown>;
-  execute(args: Record<string, unknown>, ctx?: { signal?: AbortSignal }): Promise<string>;
-}

package/src/fallback/index.ts

@@ -1,24 +0,0 @@
-import type { FallbackQuery } from "../types.js";
-import { memoryMdSnippet } from "./memoryMd.js";
-import { sessionKeywordSearch } from "./sessionSearch.js";
-
-export type { SessionSearchHit } from "./sessionSearch.js";
-export { sessionKeywordSearch } from "./sessionSearch.js";
-export { memoryMdSnippet } from "./memoryMd.js";
-
-export interface FallbackOptions {
-  sessionsDir: string;
-  memoryMdPaths: string[];
-}
-
-/** Real fallback: session JSON keyword search + MEMORY.md grep. */
-export function createFallbackQuery(opts: FallbackOptions): FallbackQuery {
-  return {
-    async sessionKeyword(query: string, limit: number) {
-      return sessionKeywordSearch(opts.sessionsDir, query, limit);
-    },
-    async memoryFileSnippet(query: string) {
-      return memoryMdSnippet(opts.memoryMdPaths, query);
-    },
-  };
-}