clawmem 0.1.0

package/src/memory.ts

@@ -0,0 +1,336 @@
+/**
+ * ClawMem Memory Module - SAME composite scoring layer
+ *
+ * Provides recency decay, confidence scoring, and composite scoring
+ * that overlays on top of QMD's raw search results.
+ */
+
+// =============================================================================
+// Content Type Half-Lives (days until score drops to 50%)
+// =============================================================================
+
+export const HALF_LIVES: Record<string, number> = {
+  handoff: 30,
+  progress: 45,
+  note: 60,
+  research: 90,
+  project: 120,
+  decision: Infinity,
+  hub: Infinity,
+};
+
+// =============================================================================
+// Confidence Baselines by Content Type
+// =============================================================================
+
+export const TYPE_BASELINES: Record<string, number> = {
+  decision: 0.85,
+  hub: 0.80,
+  research: 0.70,
+  project: 0.65,
+  handoff: 0.60,
+  progress: 0.50,
+  note: 0.50,
+};
+
+// =============================================================================
+// Content Type Inference
+// =============================================================================
+
+export type ContentType = "decision" | "hub" | "research" | "project" | "handoff" | "progress" | "note";
+
+export function inferContentType(path: string, explicitType?: string): ContentType {
+  if (explicitType && explicitType in TYPE_BASELINES) return explicitType as ContentType;
+
+  const lower = path.toLowerCase();
+  if (lower.includes("decision") || lower.includes("adr/") || lower.includes("adr-")) return "decision";
+  if (lower.includes("hub") || lower.includes("moc") || lower.match(/\/index\.md$/)) return "hub";
+  if (lower.includes("research") || lower.includes("investigation") || lower.includes("analysis")) return "research";
+  if (lower.includes("project") || lower.includes("epic") || lower.includes("initiative")) return "project";
+  if (lower.includes("handoff") || lower.includes("handover") || lower.includes("session")) return "handoff";
+  if (lower.includes("progress") || lower.includes("status") || lower.includes("standup") || lower.includes("changelog")) return "progress";
+  return "note";
+}
+
+// =============================================================================
+// Memory Type Classification (E10)
+// =============================================================================
+
+export type MemoryType = "episodic" | "semantic" | "procedural";
+
+/**
+ * Infer memory type from content metadata.
+ * - episodic: session events, handoffs, progress (time-bound)
+ * - semantic: facts, decisions, knowledge (declarative)
+ * - procedural: how-to, patterns, workflows (actionable)
+ */
+export function inferMemoryType(path: string, contentType: string, body?: string): MemoryType {
+  if (["handoff", "progress"].includes(contentType)) return "episodic";
+  if (["decision", "hub", "research"].includes(contentType)) return "semantic";
+  if (body && /\b(step\s+\d|workflow|recipe|how\s+to|procedure|runbook|playbook)\b/i.test(body)) return "procedural";
+  if (path.includes("sop") || path.includes("runbook") || path.includes("playbook")) return "procedural";
+  if (contentType === "antipattern") return "semantic";
+  return "semantic";
+}
+
+// =============================================================================
+// Recency Score
+// =============================================================================
+
+/**
+ * Compute effective half-life adjusted by access frequency.
+ * Frequently accessed memories decay slower (up to 3x base half-life).
+ */
+function effectiveHalfLife(
+  baseHalfLife: number,
+  accessCount: number,
+  lastAccessedAt?: Date | string | null,
+  now: Date = new Date()
+): number {
+  if (!isFinite(baseHalfLife) || accessCount <= 0) return baseHalfLife;
+
+  let freshness = 1.0;
+  if (lastAccessedAt) {
+    const lastAccess = typeof lastAccessedAt === "string" ? new Date(lastAccessedAt) : lastAccessedAt;
+    if (!isNaN(lastAccess.getTime())) {
+      const daysSinceAccess = (now.getTime() - lastAccess.getTime()) / (1000 * 60 * 60 * 24);
+      freshness = Math.max(0, 1 - daysSinceAccess / 90);
+    }
+  }
+
+  const extension = baseHalfLife * 0.3 * Math.log1p(accessCount * freshness);
+  return Math.min(baseHalfLife * 3, baseHalfLife + extension);
+}
+
+export function recencyScore(
+  modifiedAt: Date | string,
+  contentType: string,
+  now: Date = new Date(),
+  accessCount: number = 0,
+  lastAccessedAt?: Date | string | null
+): number {
+  const baseHalfLife = HALF_LIVES[contentType] ?? 60;
+  if (!isFinite(baseHalfLife)) return 1.0;
+
+  const halfLife = effectiveHalfLife(baseHalfLife, accessCount, lastAccessedAt, now);
+
+  const modified = typeof modifiedAt === "string" ? new Date(modifiedAt) : modifiedAt;
+  if (isNaN(modified.getTime())) return 0.5;
+  const daysSince = (now.getTime() - modified.getTime()) / (1000 * 60 * 60 * 24);
+  if (daysSince <= 0) return 1.0;
+  const result = Math.pow(0.5, daysSince / halfLife);
+  return Number.isFinite(result) ? result : 0;
+}
+
+// =============================================================================
+// Confidence Score
+// =============================================================================
+
+export function confidenceScore(
+  contentType: string,
+  modifiedAt: Date | string,
+  accessCount: number,
+  now: Date = new Date(),
+  lastAccessedAt?: Date | string | null
+): number {
+  const baseline = TYPE_BASELINES[contentType] ?? 0.5;
+  const recency = recencyScore(modifiedAt, contentType, now);
+  const safeAccess = Number.isFinite(accessCount) && accessCount >= 0 ? accessCount : 0;
+  const accessBoost = Math.min(1.5, 1 + Math.log2(1 + safeAccess) * 0.1);
+
+  // Attention decay: reduce confidence if not accessed recently (5% per week)
+  // Only apply to episodic/progress content — skip for durable types (decision, hub, research)
+  // Also skip if last_accessed_at was backfilled from modified_at (no real access yet)
+  const DECAY_EXEMPT_TYPES = new Set(["decision", "hub", "research", "antipattern"]);
+  let attentionDecay = 1.0;
+  if (lastAccessedAt && !DECAY_EXEMPT_TYPES.has(contentType)) {
+    const lastAccess = typeof lastAccessedAt === "string" ? new Date(lastAccessedAt) : lastAccessedAt;
+    const modified = typeof modifiedAt === "string" ? new Date(modifiedAt) : modifiedAt;
+    if (!isNaN(lastAccess.getTime())) {
+      // Skip decay if last_accessed_at == modified_at (backfilled, no real access)
+      const isBackfilled = Math.abs(lastAccess.getTime() - modified.getTime()) < 1000;
+      if (!isBackfilled) {
+        const daysSinceAccess = (now.getTime() - lastAccess.getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSinceAccess > 0) {
+          attentionDecay = Math.max(0.5, Math.pow(0.95, daysSinceAccess / 7));
+        }
+      }
+    }
+  }
+
+  const result = Math.min(1.0, baseline * recency * accessBoost * attentionDecay);
+  return Number.isFinite(result) ? result : 0;
+}
+
+// =============================================================================
+// Composite Scoring
+// =============================================================================
+
+export type CompositeWeights = {
+  search: number;
+  recency: number;
+  confidence: number;
+};
+
+export const DEFAULT_WEIGHTS: CompositeWeights = { search: 0.5, recency: 0.25, confidence: 0.25 };
+export const RECENCY_WEIGHTS: CompositeWeights = { search: 0.1, recency: 0.7, confidence: 0.2 };
+
+const RECENCY_PATTERNS = [
+  /\brecent(ly)?\b/i,
+  /\blast\s+(session|time|week|month|few\s+days)\b/i,
+  /\bleft\s+off\b/i,
+  /\bwhere\s+(was|were)\s+(we|i)\b/i,
+  /\bpick\s+up\b/i,
+  /\bcontinue\b/i,
+  /\byesterday\b/i,
+  /\btoday\b/i,
+  /\bwhat\s+(was|were)\s+(we|i)\s+(doing|working)\b/i,
+];
+
+export function hasRecencyIntent(query: string): boolean {
+  return RECENCY_PATTERNS.some(p => p.test(query));
+}
+
+export function compositeScore(
+  searchScore: number,
+  recency: number,
+  confidence: number,
+  weights: CompositeWeights = DEFAULT_WEIGHTS
+): number {
+  // Guard against NaN propagation
+  const s = Number.isFinite(searchScore) ? searchScore : 0;
+  const r = Number.isFinite(recency) ? recency : 0;
+  const c = Number.isFinite(confidence) ? confidence : 0;
+  const result = weights.search * s + weights.recency * r + weights.confidence * c;
+  return Number.isFinite(result) ? result : 0;
+}
+
+// =============================================================================
+// Apply Composite Scoring to Search Results
+// =============================================================================
+
+export type EnrichedResult = {
+  filepath: string;
+  displayPath: string;
+  title: string;
+  score: number;
+  body?: string;
+  contentType: string;
+  modifiedAt: string;
+  accessCount: number;
+  confidence: number;
+  qualityScore: number;
+  pinned: boolean;
+  context: string | null;
+  hash: string;
+  docid: string;
+  collectionName: string;
+  bodyLength: number;
+  source: "fts" | "vec";
+  chunkPos?: number;
+  fragmentType?: string;
+  fragmentLabel?: string;
+  lastAccessedAt?: string | null;
+  // Engram integration: frequency/evolution metadata
+  duplicateCount: number;
+  revisionCount: number;
+};
+
+export type ScoredResult = EnrichedResult & {
+  compositeScore: number;
+  recencyScore: number;
+};
+
+export type CoActivationFn = (path: string) => { path: string; count: number }[];
+
+export function applyCompositeScoring(
+  results: EnrichedResult[],
+  query: string,
+  coActivationFn?: CoActivationFn
+): ScoredResult[] {
+  const weights = hasRecencyIntent(query) ? RECENCY_WEIGHTS : DEFAULT_WEIGHTS;
+  const now = new Date();
+
+  const scored = results.map(r => {
+    const recency = recencyScore(r.modifiedAt, r.contentType, now, r.accessCount, r.lastAccessedAt);
+    const computed = confidenceScore(r.contentType, r.modifiedAt, r.accessCount, now, r.lastAccessedAt);
+    // Blend stored confidence (from contradiction lowering, feedback boosts) with computed.
+    // Default stored=0.5 → 100% computed. Stored deviations shift the result proportionally.
+    const storedConf = r.confidence ?? 0.5;
+    const conf = storedConf === 0.5 ? computed : Math.min(1.0, computed * (storedConf / 0.5) * 0.5 + computed * 0.5);
+    const composite = compositeScore(r.score, recency, conf, weights);
+
+    // Quality multiplier: 0.5 default → 1.0x (no effect)
+    // Range: 0.0 → 0.7x penalty, 1.0 → 1.3x boost
+    const qualityMultiplier = 0.7 + 0.6 * (r.qualityScore ?? 0.5);
+    let adjusted = composite * qualityMultiplier;
+
+    // Length normalization: penalize verbose entries that dominate via keyword density
+    // anchor=500 chars. At anchor → 1.0x, 1000 → 0.75x, 2000 → 0.57x. Never boosts short docs.
+    const lenRatio = Math.log2(Math.max((r.bodyLength || 500) / 500, 1));
+    const lenFactor = 1 / (1 + 0.5 * lenRatio);
+    adjusted = Math.max(adjusted * 0.3, adjusted * lenFactor);
+
+    // Engram integration: revision durability signal (Phase 3)
+    // revision_count is weighted more heavily than duplicate_count (evolution vs noise).
+    // Capped at 10% to prevent runaway amplification.
+    const revisions = (r.revisionCount || 1) - 1;
+    const duplicates = (r.duplicateCount || 1) - 1;
+    const freqSignal = revisions * 2 + duplicates; // revisions weighted 2x
+    const freqBoost = freqSignal > 0 ? Math.min(0.10, Math.log1p(freqSignal) * 0.03) : 0;
+    adjusted *= (1 + freqBoost);
+
+    // Pin boost: +0.3 additive, capped at 1.0
+    if (r.pinned) {
+      adjusted = Math.min(1.0, adjusted + 0.3);
+    }
+
+    return { ...r, compositeScore: adjusted, recencyScore: recency };
+  });
+
+  // Co-activation boost: docs frequently accessed alongside top results get a boost
+  if (coActivationFn && scored.length > 1) {
+    const topQuartile = Math.max(1, Math.floor(scored.length * 0.25));
+    // Co-activations are recorded using displayPath format (collection/path),
+    // but scored results use filepath format (clawmem://collection/path).
+    // Normalize: strip clawmem:// prefix for lookup, match back via both formats.
+    const stripPrefix = (p: string) => p.startsWith("clawmem://") ? p.slice(10) : p;
+    const topDisplayPaths = new Set(scored.slice(0, topQuartile).map(r => stripPrefix(r.filepath)));
+    const coActivatedCounts = new Map<string, number>();
+
+    for (const topPath of topDisplayPaths) {
+      const partners = coActivationFn(topPath);
+      for (const p of partners) {
+        if (!topDisplayPaths.has(p.path)) {
+          coActivatedCounts.set(p.path, (coActivatedCounts.get(p.path) || 0) + p.count);
+        }
+      }
+    }
+
+    if (coActivatedCounts.size > 0) {
+      for (const r of scored) {
+        const coCount = coActivatedCounts.get(stripPrefix(r.filepath));
+        if (coCount) {
+          // Boost capped at 15% to prevent runaway amplification
+          r.compositeScore *= 1 + Math.min(coCount / 10, 0.15);
+        }
+      }
+    }
+  }
+
+  // Sort by composite score descending
+  scored.sort((a, b) => b.compositeScore - a.compositeScore);
+
+  // Boost handoff/decision types when recency intent detected
+  if (hasRecencyIntent(query)) {
+    const priority = new Set<string>(["handoff", "decision", "progress"]);
+    scored.sort((a, b) => {
+      const aPriority = priority.has(a.contentType) ? 1 : 0;
+      const bPriority = priority.has(b.contentType) ? 1 : 0;
+      if (aPriority !== bPriority) return bPriority - aPriority;
+      return b.compositeScore - a.compositeScore;
+    });
+  }
+
+  return scored;
+}

package/src/mmr.ts

@@ -0,0 +1,93 @@
+/**
+ * MMR (Maximal Marginal Relevance) Diversity Filter
+ *
+ * Prevents top-k results from being dominated by near-duplicate entries.
+ * Uses text-based similarity (word overlap) — no vector lookups needed.
+ *
+ * Ported from memory-lancedb-pro's applyMMRDiversity(), adapted to use
+ * Jaccard similarity on word bigrams instead of cosine on vectors.
+ */
+
+import type { ScoredResult } from "./memory.ts";
+
+// =============================================================================
+// Text Similarity
+// =============================================================================
+
+function extractBigrams(text: string): Set<string> {
+  const words = text.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter(Boolean);
+  const bigrams = new Set<string>();
+  for (let i = 0; i < words.length - 1; i++) {
+    bigrams.add(`${words[i]} ${words[i + 1]}`);
+  }
+  // Also add individual words for short texts
+  for (const w of words) {
+    if (w.length > 3) bigrams.add(w);
+  }
+  return bigrams;
+}
+
+function jaccardSimilarity(a: Set<string>, b: Set<string>): number {
+  if (a.size === 0 && b.size === 0) return 1.0;
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  const smaller = a.size <= b.size ? a : b;
+  const larger = a.size <= b.size ? b : a;
+  for (const item of smaller) {
+    if (larger.has(item)) intersection++;
+  }
+  return intersection / (a.size + b.size - intersection);
+}
+
+// =============================================================================
+// MMR Diversity Filter
+// =============================================================================
+
+/**
+ * Greedily select results that are both relevant (high score) and diverse
+ * (low textual similarity to already-selected results).
+ *
+ * Results exceeding the similarity threshold against any selected result
+ * are demoted to the end rather than removed entirely.
+ *
+ * @param results - Pre-sorted by compositeScore descending
+ * @param similarityThreshold - Jaccard threshold above which results are demoted (default 0.6)
+ * @returns Reordered results with diverse items first, near-duplicates appended
+ */
+export function applyMMRDiversity(
+  results: ScoredResult[],
+  similarityThreshold: number = 0.6
+): ScoredResult[] {
+  if (results.length <= 2) return results;
+
+  const bigramCache = new Map<string, Set<string>>();
+  function getBigrams(r: ScoredResult): Set<string> {
+    const key = r.filepath;
+    let cached = bigramCache.get(key);
+    if (!cached) {
+      cached = extractBigrams(`${r.title} ${r.body || ""}`);
+      bigramCache.set(key, cached);
+    }
+    return cached;
+  }
+
+  const selected: ScoredResult[] = [];
+  const deferred: ScoredResult[] = [];
+
+  for (const candidate of results) {
+    const candidateBigrams = getBigrams(candidate);
+
+    const tooSimilar = selected.some(s => {
+      const sim = jaccardSimilarity(getBigrams(s), candidateBigrams);
+      return sim > similarityThreshold;
+    });
+
+    if (tooSimilar) {
+      deferred.push(candidate);
+    } else {
+      selected.push(candidate);
+    }
+  }
+
+  return [...selected, ...deferred];
+}

package/src/observer.ts

@@ -0,0 +1,269 @@
+/**
+ * Local Observer Agent - Structured observation extraction using local GGUF model
+ *
+ * Uses Qwen3-1.7B (already loaded for query expansion) with XML-formatted prompts
+ * to extract structured observations and session summaries from transcripts.
+ * Falls back gracefully when model is unavailable.
+ */
+
+import type { TranscriptMessage } from "./hooks.ts";
+import { getDefaultLlamaCpp } from "./llm.ts";
+import { MAX_LLM_GENERATE_TIMEOUT_MS } from "./limits.ts";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export type Observation = {
+  type: "decision" | "bugfix" | "feature" | "refactor" | "discovery" | "change";
+  title: string;
+  facts: string[];
+  narrative: string;
+  concepts: string[];
+  filesRead: string[];
+  filesModified: string[];
+};
+
+export type SessionSummary = {
+  request: string;
+  investigated: string;
+  learned: string;
+  completed: string;
+  nextSteps: string;
+};
+
+// =============================================================================
+// Config
+// =============================================================================
+
+const MAX_TRANSCRIPT_MESSAGES = 100;
+const MAX_USER_MSG_CHARS = 200;
+const MAX_ASSISTANT_MSG_CHARS = 500;
+const MAX_TRANSCRIPT_TOKENS = 2000;
+const GENERATION_MAX_TOKENS = 2000;
+const GENERATION_TEMPERATURE = 0.3;
+
+// =============================================================================
+// System Prompts
+// =============================================================================
+
+const OBSERVATION_SYSTEM_PROMPT = `You are an observer analyzing a coding session transcript. Extract structured observations.
+For each significant action, decision, or discovery, output an <observation> XML element.
+
+<observation>
+  <type>one of: decision, bugfix, feature, refactor, discovery, change</type>
+  <title>Brief descriptive title (max 80 chars)</title>
+  <facts>
+    <fact>Individual atomic fact</fact>
+  </facts>
+  <narrative>2-3 sentences explaining context and reasoning</narrative>
+  <concepts>
+    <concept>one of: how-it-works, why-it-exists, what-changed, problem-solution, gotcha, pattern, trade-off</concept>
+  </concepts>
+  <files_read><file>path/to/file</file></files_read>
+  <files_modified><file>path/to/file</file></files_modified>
+</observation>
+
+Rules:
+- Output 1-5 observations, focusing on the MOST significant events
+- Each fact should be a standalone, atomic piece of information
+- The narrative should explain WHY something was done, not just WHAT
+- Only include files that were explicitly mentioned in the transcript
+- If no significant observations, output nothing`;
+
+const SUMMARY_SYSTEM_PROMPT = `You are a session summarizer. Analyze this coding session transcript and output a structured summary.
+
+<summary>
+  <request>What the user originally asked for (1-2 sentences)</request>
+  <investigated>What was explored or researched (1-2 sentences)</investigated>
+  <learned>Key insights or discoveries (1-2 sentences)</learned>
+  <completed>What was actually accomplished (1-2 sentences)</completed>
+  <next_steps>What should happen next (1-2 sentences)</next_steps>
+</summary>
+
+Rules:
+- Be concise and specific
+- Focus on outcomes, not process
+- If a section has nothing relevant, write "None"`;
+
+// =============================================================================
+// Transcript Preparation
+// =============================================================================
+
+function prepareTranscript(messages: TranscriptMessage[]): string {
+  const recent = messages.slice(-MAX_TRANSCRIPT_MESSAGES);
+  const lines: string[] = [];
+  let charCount = 0;
+  const charBudget = MAX_TRANSCRIPT_TOKENS * 4; // ~4 chars per token
+
+  for (const msg of recent) {
+    if (charCount >= charBudget) break;
+
+    const maxChars = msg.role === "user" ? MAX_USER_MSG_CHARS : MAX_ASSISTANT_MSG_CHARS;
+    const content = msg.content.length > maxChars
+      ? msg.content.slice(0, maxChars) + "..."
+      : msg.content;
+
+    const line = `[${msg.role}]: ${content}`;
+    lines.push(line);
+    charCount += line.length;
+  }
+
+  return lines.join("\n");
+}
+
+// =============================================================================
+// XML Parsers
+// =============================================================================
+
+const VALID_OBSERVATION_TYPES = new Set([
+  "decision", "bugfix", "feature", "refactor", "discovery", "change",
+]);
+
+const VALID_CONCEPTS = new Set([
+  "how-it-works", "why-it-exists", "what-changed", "problem-solution",
+  "gotcha", "pattern", "trade-off",
+]);
+
+export function parseObservationXml(xml: string): Observation | null {
+  const typeMatch = xml.match(/<type>\s*(.*?)\s*<\/type>/s);
+  const titleMatch = xml.match(/<title>\s*(.*?)\s*<\/title>/s);
+  const narrativeMatch = xml.match(/<narrative>\s*(.*?)\s*<\/narrative>/s);
+
+  if (!typeMatch?.[1] || !titleMatch?.[1]) return null;
+
+  const type = typeMatch[1].trim().toLowerCase();
+  if (!VALID_OBSERVATION_TYPES.has(type)) return null;
+
+  const facts = extractMultiple(xml, "fact");
+  const concepts = extractMultiple(xml, "concept")
+    .filter(c => VALID_CONCEPTS.has(c.toLowerCase()))
+    .map(c => c.toLowerCase());
+  const filesRead = extractMultiple(xml, "file", "files_read");
+  const filesModified = extractMultiple(xml, "file", "files_modified");
+
+  return {
+    type: type as Observation["type"],
+    title: titleMatch[1].trim().slice(0, 80),
+    facts: facts.filter(f => f.length >= 5),
+    narrative: narrativeMatch?.[1]?.trim() || "",
+    concepts,
+    filesRead,
+    filesModified,
+  };
+}
+
+export function parseSummaryXml(xml: string): SessionSummary | null {
+  const request = extractSingle(xml, "request");
+  const investigated = extractSingle(xml, "investigated");
+  const learned = extractSingle(xml, "learned");
+  const completed = extractSingle(xml, "completed");
+  const nextSteps = extractSingle(xml, "next_steps");
+
+  if (!request && !completed) return null;
+
+  return {
+    request: request || "Unknown",
+    investigated: investigated || "None",
+    learned: learned || "None",
+    completed: completed || "None",
+    nextSteps: nextSteps || "None",
+  };
+}
+
+function extractSingle(xml: string, tag: string): string | null {
+  const match = xml.match(new RegExp(`<${tag}>\\s*(.*?)\\s*</${tag}>`, "s"));
+  return match?.[1]?.trim() || null;
+}
+
+function extractMultiple(xml: string, tag: string, parentTag?: string): string[] {
+  let scope = xml;
+  if (parentTag) {
+    const parentMatch = xml.match(new RegExp(`<${parentTag}>([\\s\\S]*?)</${parentTag}>`, "s"));
+    if (!parentMatch?.[1]) return [];
+    scope = parentMatch[1];
+  }
+
+  const results: string[] = [];
+  const regex = new RegExp(`<${tag}>\\s*(.*?)\\s*</${tag}>`, "gs");
+  let match;
+  while ((match = regex.exec(scope)) !== null) {
+    const text = match[1]?.trim();
+    if (text) results.push(text);
+  }
+  return results;
+}
+
+// =============================================================================
+// Core Extraction Functions
+// =============================================================================
+
+export async function extractObservations(
+  messages: TranscriptMessage[]
+): Promise<Observation[]> {
+  if (messages.length < 4) return [];
+
+  const transcript = prepareTranscript(messages);
+  const prompt = `${OBSERVATION_SYSTEM_PROMPT}\n\n--- TRANSCRIPT ---\n${transcript}\n--- END TRANSCRIPT ---\n\nExtract observations:`;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), MAX_LLM_GENERATE_TIMEOUT_MS);
+  try {
+    const llm = getDefaultLlamaCpp();
+    const result = await llm.generate(prompt, {
+      maxTokens: GENERATION_MAX_TOKENS,
+      temperature: GENERATION_TEMPERATURE,
+      signal: controller.signal,
+    });
+
+    if (!result?.text) return [];
+
+    // Parse all <observation>...</observation> blocks
+    const observations: Observation[] = [];
+    const regex = /<observation>([\s\S]*?)<\/observation>/g;
+    let match;
+    while ((match = regex.exec(result.text)) !== null) {
+      const obs = parseObservationXml(match[1]!);
+      if (obs) observations.push(obs);
+    }
+
+    return observations;
+  } catch (err) {
+    console.error("Observer: observation extraction failed:", err);
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function extractSummary(
+  messages: TranscriptMessage[]
+): Promise<SessionSummary | null> {
+  if (messages.length < 4) return null;
+
+  const transcript = prepareTranscript(messages);
+  const prompt = `${SUMMARY_SYSTEM_PROMPT}\n\n--- TRANSCRIPT ---\n${transcript}\n--- END TRANSCRIPT ---\n\nGenerate summary:`;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), MAX_LLM_GENERATE_TIMEOUT_MS);
+  try {
+    const llm = getDefaultLlamaCpp();
+    const result = await llm.generate(prompt, {
+      maxTokens: 500,
+      temperature: GENERATION_TEMPERATURE,
+      signal: controller.signal,
+    });
+
+    if (!result?.text) return null;
+
+    const summaryMatch = result.text.match(/<summary>([\s\S]*?)<\/summary>/);
+    if (!summaryMatch?.[1]) return null;
+
+    return parseSummaryXml(summaryMatch[1]);
+  } catch (err) {
+    console.error("Observer: summary extraction failed:", err);
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}