@brianmichel/pi-noodle 0.1.0

package/src/memory/extractor.ts

@@ -0,0 +1,189 @@
+import { complete } from "@earendil-works/pi-ai";
+import type { Api, Model, Message } from "@earendil-works/pi-ai";
+
+import type {
+  ExtractionCandidate,
+  ExtractionSensitivity,
+  ExtractionStability,
+  MemoryApplicability,
+  MemoryCategory,
+  MemoryDurability,
+  MemoryMessage,
+} from "./types.ts";
+
+const SYSTEM_PROMPT = `You extract durable, memorable facts from AI assistant conversations.
+
+Return a JSON array of memory objects. Each object must have:
+- "text": string — concise third-person statement, max 120 chars (e.g. "User prefers TypeScript for new projects")
+- "category": one of "identity" | "response_style" | "coding_pref" | "workflow" | "project"
+- "durability": one of "durable" | "semi_durable"
+- "confidence": number 0.0–1.0
+- "reason": string — short machine-readable reason such as "explicit_statement" | "repeated_pattern" | "inferred_from_behavior"
+- "stability": one of "stable" | "likely_stable" | "uncertain"
+- "sensitivity": one of "safe" | "sensitive"
+- "suggestedAction": one of "save" | "pending" | "discard"
+- "applicability": one of "user" | "project" | "unknown"
+- "applicabilityConfidence": number 0.0–1.0
+- "applicabilityReason": string — short explanation for why this applies broadly vs to the current project
+
+Rules:
+- Only extract facts stable across sessions — not task-specific details
+- Prioritize user defaults, repeated habits, negative preferences, and project conventions likely to matter later
+- Prefer facts stated by the user over assistant speculation
+- "project" means the fact seems tied to the current codebase, product, feature, or initiative rather than the user's broad cross-project preference
+- Prefer "user" only when the user clearly states a general habit or default likely to apply across unrelated projects
+- Use "unknown" when the distinction is ambiguous
+- Skip: file contents, code snippets, transient decisions, error messages, tool results
+- Skip: credentials, API keys, tokens, passwords, private secrets, financial details, and medical details
+- Skip: conversational mechanics ("the user asked", "I replied")
+- Skip: anything that only matters for the current task, file, or response
+- Identity facts (name, role, background) → durable. Preferences and conventions → semi_durable.
+- Use "pending" for plausible but not yet certain durable preferences.
+- Use "discard" when something looks transient, risky, or not worth long-term memory.
+- Be conservative: return [] if nothing clearly warrants long-term memory
+- Return ONLY the JSON array, no other text`;
+
+type RawCandidate = {
+  text?: unknown;
+  category?: unknown;
+  durability?: unknown;
+  confidence?: unknown;
+  reason?: unknown;
+  stability?: unknown;
+  sensitivity?: unknown;
+  suggestedAction?: unknown;
+  applicability?: unknown;
+  applicabilityConfidence?: unknown;
+  applicabilityReason?: unknown;
+};
+
+const VALID_CATEGORIES = new Set<string>(["identity", "response_style", "coding_pref", "workflow", "project"]);
+const VALID_DURABILITIES = new Set<string>(["durable", "semi_durable"]);
+const VALID_STABILITIES = new Set<string>(["stable", "likely_stable", "uncertain"]);
+const VALID_SENSITIVITIES = new Set<string>(["safe", "sensitive"]);
+const VALID_ACTIONS = new Set<string>(["save", "pending", "discard"]);
+const VALID_APPLICABILITY = new Set<string>(["user", "project", "unknown"]);
+
+function normalizeStability(raw: unknown): ExtractionStability {
+  return typeof raw === "string" && VALID_STABILITIES.has(raw) ? raw as ExtractionStability : "uncertain";
+}
+
+function normalizeSensitivity(raw: unknown): ExtractionSensitivity {
+  return typeof raw === "string" && VALID_SENSITIVITIES.has(raw) ? raw as ExtractionSensitivity : "safe";
+}
+
+function normalizeApplicability(raw: unknown): MemoryApplicability {
+  return typeof raw === "string" && VALID_APPLICABILITY.has(raw) ? raw as MemoryApplicability : "unknown";
+}
+
+function isValidCandidate(raw: unknown): raw is ExtractionCandidate {
+  if (!raw || typeof raw !== "object") return false;
+  const r = raw as RawCandidate;
+  if (typeof r.text !== "string" || r.text.trim().length === 0) return false;
+  if (typeof r.category !== "string" || !VALID_CATEGORIES.has(r.category)) return false;
+  if (typeof r.durability !== "string" || !VALID_DURABILITIES.has(r.durability)) return false;
+  if (typeof r.confidence !== "number" || r.confidence < 0 || r.confidence > 1) return false;
+  return true;
+}
+
+function parseJsonArray(content: string): unknown[] {
+  const trimmed = content.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+    if (parsed && typeof parsed === "object") {
+      for (const val of Object.values(parsed)) {
+        if (Array.isArray(val)) return val;
+      }
+    }
+  } catch {
+    const match = trimmed.match(/\[[\s\S]*\]/);
+    if (match) {
+      try {
+        const arr = JSON.parse(match[0]);
+        if (Array.isArray(arr)) return arr;
+      } catch {
+        // unparseable
+      }
+    }
+  }
+  return [];
+}
+
+export function parseExtractedCandidates(content: string): ExtractionCandidate[] {
+  if (!content) return [];
+
+  const raw = parseJsonArray(content);
+
+  return raw
+    .filter(isValidCandidate)
+    .map((c) => {
+      const applicabilityConfidence = typeof (c as RawCandidate).applicabilityConfidence === "number"
+        ? ((c as RawCandidate).applicabilityConfidence as number)
+        : undefined;
+      const applicabilityReason = typeof (c as RawCandidate).applicabilityReason === "string"
+        ? ((c as RawCandidate).applicabilityReason as string)
+        : undefined;
+
+      return {
+        text: (c as ExtractionCandidate).text.trim(),
+        category: (c as ExtractionCandidate).category as MemoryCategory,
+        durability: (c as ExtractionCandidate).durability as MemoryDurability,
+        confidence: (c as ExtractionCandidate).confidence,
+        reason: typeof (c as RawCandidate).reason === "string"
+          ? ((c as RawCandidate).reason as string)
+          : "llm_extracted",
+        stability: normalizeStability((c as RawCandidate).stability),
+        sensitivity: normalizeSensitivity((c as RawCandidate).sensitivity),
+        suggestedAction: typeof (c as RawCandidate).suggestedAction === "string" && VALID_ACTIONS.has((c as RawCandidate).suggestedAction as string)
+          ? ((c as RawCandidate).suggestedAction as "save" | "pending" | "discard")
+          : "pending",
+        applicability: normalizeApplicability((c as RawCandidate).applicability),
+        ...(applicabilityConfidence !== undefined ? { applicabilityConfidence } : {}),
+        ...(applicabilityReason ? { applicabilityReason } : {}),
+      };
+    });
+}
+
+export async function extractMemoriesFromMessages(
+  messages: MemoryMessage[],
+  model: Model<Api>,
+  options?: { apiKey?: string; headers?: Record<string, string>; signal?: AbortSignal },
+): Promise<ExtractionCandidate[]> {
+  if (messages.length === 0) return [];
+
+  const conversationText = messages
+    .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`)
+    .join("\n\n");
+
+  const userMessage: Message = {
+    role: "user",
+    content: [{
+      type: "text",
+      text: `Extract memorable facts from this conversation:\n\n${conversationText}`,
+    }],
+    timestamp: Date.now(),
+  };
+
+  // Use complete() rather than completeSimple() so we can pass the API key
+  // and headers resolved from ctx.modelRegistry.getApiKeyAndHeaders().
+  // completeSimple() accepts options but doesn't get auth from the model
+  // registry — it only checks env vars, which misses SSO/OAuth setups.
+  const result = await complete(model, {
+    systemPrompt: SYSTEM_PROMPT,
+    messages: [userMessage],
+  }, {
+    temperature: 0,
+    maxTokens: 1000,
+    ...(options?.apiKey ? { apiKey: options.apiKey } : {}),
+    ...(options?.headers ? { headers: options.headers } : {}),
+    ...(options?.signal ? { signal: options.signal } : {}),
+  });
+
+  const content = result.content
+    .filter((c) => c.type === "text")
+    .map((c) => (c as { type: "text"; text: string }).text)
+    .join("");
+
+  return parseExtractedCandidates(content);
+}

package/src/memory/policy.ts

@@ -0,0 +1,325 @@
+import type {
+  LocalSignal,
+  MemoryApplicability,
+  MemoryCandidate,
+  MemoryCategory,
+  MemoryDurability,
+  MemoryPolicyDecision,
+  PrefilterResult,
+} from "./types.ts";
+import type { NoodleExtractorMode } from "../types.ts";
+
+const EXPLICIT_PATTERNS: Array<{
+  pattern: RegExp;
+  category: MemoryCategory;
+  durability: MemoryDurability;
+  reason: string;
+  confidence?: number;
+  explicit?: boolean;
+}> = [
+  {
+    pattern: /\bremember(?:\s+that)?\s+([^.!?\n]+)/i,
+    category: "project",
+    durability: "semi_durable",
+    reason: "explicit_memory_request",
+    confidence: 0.99,
+    explicit: true,
+  },
+];
+
+const RETRIEVAL_PATTERNS: RegExp[] = [
+  /\b(call me|what should you call me|my name|nickname)\b/i,
+  /\b(prefer|by default|always|never|concise|verbose|brief|detailed|usually|normally|avoid|should i use|should i avoid)\b/i,
+  /\b(code|implement|refactor|fix|review|format|summari[sz]e|plan|debug|test|language|runtime|stack|daemon|backend|script)\b/i,
+];
+
+const TEMPORARY_PATTERNS: RegExp[] = [
+  /\b(for this|this time|for now|today only|in this response|for this task|for this file|for this repo)\b/i,
+  /\b(current task|temporary|right now)\b/i,
+];
+
+const SENSITIVE_PATTERNS: RegExp[] = [
+  /\b(api[_ -]?key|token|secret|password|passwd|private key|ssh key|oauth)\b/i,
+  /\bm0sk_[a-z0-9]+\b/i,
+  /\bsk-[a-z0-9]+\b/i,
+  /authorization:\s*bearer/i,
+];
+
+const STYLE_HINTS = /\b(concise|brief|short|verbose|detailed|bullet points?|markdown|plain text)\b/i;
+const CODING_CONTEXT_HINTS = /\b(code|coding|implementation|implement|function|script|library|framework|stack|tool|tooling|test|testing|formatter|lint|cli|backend|frontend|language|daemon)\b/i;
+const GENERAL_APPLICABILITY_HINTS = /\b(in general|generally|usually|normally|by default|always|never|across projects?)\b/i;
+const PROJECT_APPLICABILITY_HINTS = /\b(for this project|in this project|for this repo|in this repo|for this codebase|in this codebase|for this app|for this feature|for this refactor|for this component|for the web viewer|for this viewer|current project|current codebase)\b/i;
+
+function normalizeMemoryText(text: string): string {
+  return text
+    .trim()
+    .replace(/^that\s+/i, "")
+    .replace(/^to\s+/i, "")
+    .replace(/\s+/g, " ")
+    .replace(/[.]+$/, "");
+}
+
+function canonicalizeCandidateText(_category: MemoryCategory, _sourceText: string, extracted: string, _reason: string): string {
+  return extracted;
+}
+
+function inferCategory(text: string, fallback: MemoryCategory, _reason: string): MemoryCategory {
+  if (/\b(call me|my name|nickname)\b/i.test(text)) return "identity";
+  if (STYLE_HINTS.test(text)) return "response_style";
+  if (CODING_CONTEXT_HINTS.test(text)) return "coding_pref";
+  return fallback;
+}
+
+function inferDurability(text: string, fallback: MemoryDurability): MemoryDurability {
+  if (TEMPORARY_PATTERNS.some((pattern) => pattern.test(text))) return "ephemeral";
+  return fallback;
+}
+
+function confidenceFor(entry: { confidence?: number }, category: MemoryCategory): number {
+  if (typeof entry.confidence === "number") return entry.confidence;
+  return category === "identity" ? 0.96 : 0.8;
+}
+
+function inferApplicability(text: string, category: MemoryCategory): MemoryApplicability {
+  if (PROJECT_APPLICABILITY_HINTS.test(text)) return "project";
+  if (GENERAL_APPLICABILITY_HINTS.test(text)) return "user";
+  if (category === "identity" || category === "response_style") return "user";
+  if (category === "project") return "project";
+  return "unknown";
+}
+
+export function buildSignalKey(candidate: MemoryCandidate): string {
+  return `${candidate.category}:${candidate.normalized}`;
+}
+
+export function shouldBlockSensitiveMemory(text: string): boolean {
+  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+export function shouldRetrieveMemories(prompt: string): boolean {
+  return RETRIEVAL_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+
+export function categoriesForPrompt(prompt: string): MemoryCategory[] {
+  const categories: MemoryCategory[] = ["identity", "response_style"];
+
+  if (/\b(code|implement|implementation|refactor|fix|test|review|debug|scripts?|function|library|framework|tool|tooling|stack|daemon|backend|services?|language|runtime)\b/i.test(prompt)) {
+    categories.push("coding_pref", "workflow");
+  }
+
+  if (/\b(repo|project|convention|branch|workflow|team|codebase|stack)\b/i.test(prompt)) {
+    categories.push("project", "workflow");
+  }
+
+  return Array.from(new Set(categories));
+}
+
+export function tokenizePrompt(text: string): string[] {
+  return text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/i)
+    .filter((token) => token.length >= 3);
+}
+
+export function scoreMemoryText(memoryText: string, queryTokens: string[], categories: string[], memoryCategories: string[], durability?: unknown): number {
+  let score = 0;
+  const normalizedText = memoryText.toLowerCase();
+
+  for (const token of queryTokens) {
+    if (normalizedText.includes(token)) score += 2;
+  }
+
+  for (const category of categories) {
+    if (memoryCategories.includes(category)) score += 3;
+  }
+
+  if (durability === "durable") score += 1;
+  return score;
+}
+
+// The extractor can suggest an action, but local policy makes the final decision.
+// This keeps persistence deterministic, testable, and easy to tune by mode.
+export function evaluateCandidateDecision(
+  candidate: MemoryCandidate,
+  signal: LocalSignal,
+  mode: NoodleExtractorMode = "balanced",
+): MemoryPolicyDecision {
+  let score = 0;
+  const reasons: string[] = [];
+
+  // 1. Explicit asks should be saved immediately.
+  if (candidate.explicit) {
+    score += 10;
+    reasons.push("explicit_request");
+  }
+
+  // 2. Identity facts are durable and usually useful later.
+  if (candidate.category === "identity") {
+    score += 6;
+    reasons.push("identity_fact");
+  }
+
+  // 3. Strong wording (negative preferences/defaults/standards) is high-value.
+  if (candidate.reasons.includes("negative_preference")) {
+    score += 5;
+    reasons.push("negative_preference");
+  } else if (candidate.reasons.includes("strong_preference")) {
+    score += 4;
+    reasons.push("strong_preference");
+  } else if (candidate.reasons.some((reason) => ["default_preference", "workflow_default", "project_standard", "project_default", "project_stack", "tech_decision"].includes(reason))) {
+    score += 3;
+    reasons.push("project_or_default_convention");
+  }
+
+  // 4. Repetition is the safest non-explicit promotion signal.
+  if (signal.count >= 4) {
+    score += 5;
+    reasons.push("repeated_signal");
+  } else if (signal.count >= 3) {
+    score += 4;
+    reasons.push("repeated_signal");
+  } else if (signal.count >= 2) {
+    score += 3;
+    reasons.push("repeated_signal");
+  }
+
+  // 5. Confidence should help, but not overrule durability/repetition by itself.
+  if (signal.strongestConfidence >= 0.9) {
+    score += 2;
+    reasons.push("very_high_confidence");
+  } else if (signal.strongestConfidence >= 0.75) {
+    score += 1;
+    reasons.push("high_confidence");
+  }
+
+  // 6. Retrieval telemetry is weak but useful evidence that the fact mattered.
+  if ((signal.retrievalCount ?? 0) >= 3) {
+    score += 2;
+    reasons.push("retrieved_repeatedly");
+  } else if ((signal.retrievalCount ?? 0) >= 1) {
+    score += 1;
+    reasons.push("retrieved_once");
+  }
+
+  // 7. Durable preference categories deserve some weight even before they repeat a lot.
+  if (candidate.category === "coding_pref" || candidate.category === "response_style") {
+    score += 1;
+    reasons.push("preference_category");
+  }
+
+  // 8. Project standards / stack declarations are valuable even on first mention.
+  if (candidate.category === "project" && candidate.reasons.some((reason) => ["project_standard", "project_stack", "tech_decision"].includes(reason))) {
+    score += 2;
+    reasons.push("project_convention");
+  }
+
+  // 9. Durable memories get a slight nudge over semi-durable habits.
+  if (candidate.durability === "durable") {
+    score += 1;
+    reasons.push("durable");
+  }
+
+  const sensitivity = candidate.metadata["sensitivity"];
+  if (sensitivity === "sensitive") {
+    reasons.push("sensitive_blocked");
+    return {
+      action: "discard",
+      score,
+      shouldPromote: false,
+      reasons,
+    };
+  }
+
+  if (candidate.explicit) {
+    return { action: "save", score, shouldPromote: true, reasons };
+  }
+
+  if (candidate.category === "identity" && signal.strongestConfidence >= 0.9) {
+    return { action: "save", score, shouldPromote: true, reasons };
+  }
+
+  if (mode === "conservative") {
+    if (score >= 7) return { action: "save", score, shouldPromote: true, reasons };
+    return { action: "discard", score, shouldPromote: false, reasons };
+  }
+
+  if (score >= (mode === "proactive" ? 6 : 5)) {
+    return { action: "save", score, shouldPromote: true, reasons };
+  }
+
+  const isPreferenceLike = candidate.category === "coding_pref" || candidate.category === "response_style" || candidate.category === "workflow" || candidate.category === "project";
+  const confidenceFloor = mode === "proactive" ? 0.65 : 0.72;
+  if (isPreferenceLike && signal.strongestConfidence >= confidenceFloor) {
+    return { action: "pending", score, shouldPromote: false, reasons };
+  }
+
+  return { action: "discard", score, shouldPromote: false, reasons };
+}
+
+export function evaluateCandidatePromotion(candidate: MemoryCandidate, signal: LocalSignal): {
+  score: number;
+  shouldPromote: boolean;
+  reasons: string[];
+} {
+  const decision = evaluateCandidateDecision(candidate, signal, "balanced");
+  return {
+    score: decision.score,
+    shouldPromote: decision.shouldPromote,
+    reasons: decision.reasons,
+  };
+}
+
+export function prefilterUserMessage(text: string): PrefilterResult {
+  const candidates: MemoryCandidate[] = [];
+  const candidateReasons = new Set<string>();
+
+  if (shouldBlockSensitiveMemory(text)) {
+    return {
+      hasCandidate: false,
+      shouldRetrieve: shouldRetrieveMemories(text),
+      candidateReasons: ["sensitive_content_blocked"],
+      candidates,
+    };
+  }
+
+  for (const entry of EXPLICIT_PATTERNS) {
+    const match = text.match(entry.pattern);
+    if (!match) continue;
+
+    const rawExtracted = normalizeMemoryText(match[1] || match[2] || match[0]);
+    if (!rawExtracted) continue;
+
+    const category = inferCategory(text, entry.category, entry.reason);
+    const durability = inferDurability(text, entry.durability);
+    if (durability === "ephemeral") continue;
+
+    const extracted = rawExtracted.replace(/^use\s+/i, "");
+    const canonicalText = canonicalizeCandidateText(category, text, extracted, entry.reason);
+    candidateReasons.add(entry.reason);
+    const applicability = inferApplicability(text, category);
+    candidates.push({
+      text: canonicalText,
+      normalized: canonicalText.toLowerCase(),
+      category,
+      durability,
+      applicability,
+      source: entry.reason === "explicit_memory_request" ? "explicit" : "heuristic",
+      confidence: confidenceFor(entry, category),
+      explicit: entry.explicit === true,
+      reasons: [entry.reason],
+      metadata: {
+        trigger: entry.reason,
+        applicability,
+      },
+    });
+  }
+
+  const deduped = Array.from(new Map(candidates.map((candidate) => [buildSignalKey(candidate), candidate])).values());
+
+  return {
+    hasCandidate: deduped.length > 0,
+    shouldRetrieve: shouldRetrieveMemories(text),
+    candidateReasons: Array.from(candidateReasons),
+    candidates: deduped,
+  };
+}

package/src/memory/project-identity.ts

@@ -0,0 +1,51 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+
+function runGit(args: string[], cwd: string): string | null {
+  try {
+    const output = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+
+export function normalizeGitRemote(remote: string): string | null {
+  const trimmed = remote.trim();
+  if (!trimmed) return null;
+
+  const withoutGitSuffix = trimmed.replace(/\.git$/i, "");
+  const sshLike = withoutGitSuffix.match(/^(?:ssh:\/\/)?git@([^/:]+)[:/]([^\s]+)$/i);
+  if (sshLike) {
+    return `${sshLike[1]}/${sshLike[2]}`.replace(/^\/*/, "");
+  }
+
+  try {
+    const url = new URL(withoutGitSuffix);
+    if (!url.hostname || !url.pathname) return null;
+    return `${url.hostname}${url.pathname}`.replace(/^\/*/, "");
+  } catch {
+    return null;
+  }
+}
+
+export function deriveProjectKey(cwd = process.cwd()): string | null {
+  const absoluteCwd = resolve(cwd);
+  const repoRoot = runGit(["rev-parse", "--show-toplevel"], absoluteCwd);
+  const gitCwd = repoRoot ?? absoluteCwd;
+
+  const remote = runGit(["config", "--get", "remote.origin.url"], gitCwd);
+  const normalizedRemote = remote ? normalizeGitRemote(remote) : null;
+  if (normalizedRemote) return normalizedRemote;
+
+  try {
+    return `cwd:${realpathSync(gitCwd)}`;
+  } catch {
+    return `cwd:${gitCwd}`;
+  }
+}

package/src/memory/runtime.ts

@@ -0,0 +1,70 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { createClient } from "@libsql/client";
+import { DEFAULT_EXTRACTOR_MODE, defaultExtractorTriggerEvery, resolveConfig } from "../config.ts";
+import type { NoodleConfig } from "../types.ts";
+import type { MemoryBackend } from "./backend.ts";
+import { createOpenAIEmbedder } from "./embedders/openai.ts";
+import { MemoryService } from "./service.ts";
+import { TursoBackend } from "./turso-backend.ts";
+
+// ---------------------------------------------------------------------------
+// Runtime wiring
+//
+// Config is resolved from:
+//   1. Defaults         — local DB at ~/.pi/noodle/memories.db, OpenAI embedder
+//   2. ~/.pi/noodle/config.json  — persisted by /noodle settings
+//   3. Environment variables  — NOODLE_DB_PATH, OPENAI_API_KEY, etc.
+//
+// Use /noodle in Pi to view the current config.
+// Use /noodle settings to configure interactively.
+// ---------------------------------------------------------------------------
+
+function createBackend(config: NoodleConfig): MemoryBackend {
+  if (config.db.mode === "local") {
+    mkdirSync(dirname(config.db.path), { recursive: true });
+  }
+
+  let dbUrl: string;
+  if (config.db.mode === "cloud") {
+    dbUrl = config.db.url ?? "libsql://";
+  } else {
+    dbUrl = `file:${config.db.path}`;
+  }
+
+  const embedder = createOpenAIEmbedder({
+    apiKey: config.embedding.apiKey,
+    baseUrl: config.embedding.baseUrl,
+    ...(config.embedding.model ? { model: config.embedding.model } : {}),
+    ...(config.embedding.dimensions ? { dimensions: config.embedding.dimensions } : {}),
+  });
+
+  const dbOptions: Record<string, unknown> = { url: dbUrl };
+  if (config.db.mode === "cloud" && config.db.authToken) {
+    dbOptions.authToken = config.db.authToken;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const db = createClient(dbOptions as any);
+  return new TursoBackend(db, embedder, {
+    provider: config.embedding.provider,
+    model: config.embedding.model,
+    baseUrl: config.embedding.baseUrl,
+  });
+}
+
+const config = resolveConfig();
+export const memoryService = new MemoryService(createBackend(config), {
+  extractorMode: config.extractor?.mode ?? DEFAULT_EXTRACTOR_MODE,
+  extractorTriggerEvery: config.extractor?.triggerEvery ?? defaultExtractorTriggerEvery((config.extractor?.mode ?? DEFAULT_EXTRACTOR_MODE) === "off" ? DEFAULT_EXTRACTOR_MODE : (config.extractor?.mode ?? DEFAULT_EXTRACTOR_MODE)),
+});
+
+/** Behavior profile for proactive extraction. */
+export const extractorMode = config.extractor?.mode ?? DEFAULT_EXTRACTOR_MODE;
+/** Model ID to use for extraction. Extraction is skipped when unset. */
+export const extractorModelId = config.extractor?.model ?? undefined;
+/** How many user turns trigger an extraction pass. */
+export const extractorTriggerEvery = config.extractor?.triggerEvery ?? defaultExtractorTriggerEvery(extractorMode === "off" ? DEFAULT_EXTRACTOR_MODE : extractorMode);
+/** Whether to show the extractor debug widget in Pi. */
+export const extractorDebug = config.extractor?.debug ?? false;