engrm 0.4.21 → 0.4.23

package/dist/hooks/session-start.js

@@ -473,6 +473,729 @@ function normalizeItem(value) {
   return value.toLowerCase().replace(/\*+/g, "").replace(/\s+/g, " ").trim();
 }
 
+// src/tools/save.ts
+import { relative, isAbsolute } from "node:path";
+
+// src/capture/scrubber.ts
+var DEFAULT_PATTERNS = [
+  {
+    source: "sk-[a-zA-Z0-9]{20,}",
+    flags: "g",
+    replacement: "[REDACTED_API_KEY]",
+    description: "OpenAI API keys",
+    category: "api_key",
+    severity: "critical"
+  },
+  {
+    source: "Bearer [a-zA-Z0-9\\-._~+/]+=*",
+    flags: "g",
+    replacement: "[REDACTED_BEARER]",
+    description: "Bearer auth tokens",
+    category: "token",
+    severity: "medium"
+  },
+  {
+    source: "password[=:]\\s*\\S+",
+    flags: "gi",
+    replacement: "password=[REDACTED]",
+    description: "Passwords in config",
+    category: "password",
+    severity: "high"
+  },
+  {
+    source: "postgresql://[^\\s]+",
+    flags: "g",
+    replacement: "[REDACTED_DB_URL]",
+    description: "PostgreSQL connection strings",
+    category: "db_url",
+    severity: "high"
+  },
+  {
+    source: "mongodb://[^\\s]+",
+    flags: "g",
+    replacement: "[REDACTED_DB_URL]",
+    description: "MongoDB connection strings",
+    category: "db_url",
+    severity: "high"
+  },
+  {
+    source: "mysql://[^\\s]+",
+    flags: "g",
+    replacement: "[REDACTED_DB_URL]",
+    description: "MySQL connection strings",
+    category: "db_url",
+    severity: "high"
+  },
+  {
+    source: "AKIA[A-Z0-9]{16}",
+    flags: "g",
+    replacement: "[REDACTED_AWS_KEY]",
+    description: "AWS access keys",
+    category: "api_key",
+    severity: "critical"
+  },
+  {
+    source: "ghp_[a-zA-Z0-9]{36}",
+    flags: "g",
+    replacement: "[REDACTED_GH_TOKEN]",
+    description: "GitHub personal access tokens",
+    category: "token",
+    severity: "high"
+  },
+  {
+    source: "gho_[a-zA-Z0-9]{36}",
+    flags: "g",
+    replacement: "[REDACTED_GH_TOKEN]",
+    description: "GitHub OAuth tokens",
+    category: "token",
+    severity: "high"
+  },
+  {
+    source: "github_pat_[a-zA-Z0-9_]{22,}",
+    flags: "g",
+    replacement: "[REDACTED_GH_TOKEN]",
+    description: "GitHub fine-grained PATs",
+    category: "token",
+    severity: "high"
+  },
+  {
+    source: "cvk_[a-f0-9]{64}",
+    flags: "g",
+    replacement: "[REDACTED_CANDENGO_KEY]",
+    description: "Candengo API keys",
+    category: "api_key",
+    severity: "critical"
+  },
+  {
+    source: "xox[bpras]-[a-zA-Z0-9\\-]+",
+    flags: "g",
+    replacement: "[REDACTED_SLACK_TOKEN]",
+    description: "Slack tokens",
+    category: "token",
+    severity: "high"
+  }
+];
+function compileCustomPatterns(patterns) {
+  const compiled = [];
+  for (const pattern of patterns) {
+    try {
+      new RegExp(pattern);
+      compiled.push({
+        source: pattern,
+        flags: "g",
+        replacement: "[REDACTED_CUSTOM]",
+        description: `Custom pattern: ${pattern}`,
+        category: "custom",
+        severity: "medium"
+      });
+    } catch {}
+  }
+  return compiled;
+}
+function scrubSecrets(text, customPatterns = []) {
+  let result = text;
+  const allPatterns = [...DEFAULT_PATTERNS, ...compileCustomPatterns(customPatterns)];
+  for (const pattern of allPatterns) {
+    result = result.replace(new RegExp(pattern.source, pattern.flags), pattern.replacement);
+  }
+  return result;
+}
+function containsSecrets(text, customPatterns = []) {
+  const allPatterns = [...DEFAULT_PATTERNS, ...compileCustomPatterns(customPatterns)];
+  for (const pattern of allPatterns) {
+    if (new RegExp(pattern.source, pattern.flags).test(text))
+      return true;
+  }
+  return false;
+}
+
+// src/capture/quality.ts
+var QUALITY_THRESHOLD = 0.1;
+function scoreQuality(input) {
+  let score = 0;
+  switch (input.type) {
+    case "bugfix":
+      score += 0.3;
+      break;
+    case "decision":
+      score += 0.3;
+      break;
+    case "discovery":
+      score += 0.2;
+      break;
+    case "pattern":
+      score += 0.2;
+      break;
+    case "feature":
+      score += 0.15;
+      break;
+    case "refactor":
+      score += 0.15;
+      break;
+    case "change":
+      score += 0.05;
+      break;
+    case "digest":
+      score += 0.3;
+      break;
+    case "standard":
+      score += 0.25;
+      break;
+    case "message":
+      score += 0.1;
+      break;
+  }
+  if (input.narrative && input.narrative.length > 50) {
+    score += 0.15;
+  }
+  if (input.facts) {
+    try {
+      const factsArray = JSON.parse(input.facts);
+      if (factsArray.length >= 2)
+        score += 0.15;
+      else if (factsArray.length === 1)
+        score += 0.05;
+    } catch {
+      if (input.facts.length > 20)
+        score += 0.05;
+    }
+  }
+  if (input.concepts) {
+    try {
+      const conceptsArray = JSON.parse(input.concepts);
+      if (conceptsArray.length >= 1)
+        score += 0.1;
+    } catch {
+      if (input.concepts.length > 10)
+        score += 0.05;
+    }
+  }
+  const modifiedCount = input.filesModified?.length ?? 0;
+  if (modifiedCount >= 3)
+    score += 0.2;
+  else if (modifiedCount >= 1)
+    score += 0.1;
+  if (input.isDuplicate) {
+    score -= 0.3;
+  }
+  return Math.max(0, Math.min(1, score));
+}
+function meetsQualityThreshold(input) {
+  return scoreQuality(input) >= QUALITY_THRESHOLD;
+}
+
+// src/capture/facts.ts
+var FACT_ELIGIBLE_TYPES = new Set([
+  "bugfix",
+  "decision",
+  "discovery",
+  "pattern",
+  "feature",
+  "refactor",
+  "change"
+]);
+function buildStructuredFacts(input) {
+  const seedFacts = dedupeFacts(input.facts ?? []);
+  if (!FACT_ELIGIBLE_TYPES.has(input.type)) {
+    return seedFacts;
+  }
+  const derived = [...seedFacts];
+  if (seedFacts.length === 0 && looksMeaningful(input.title)) {
+    derived.push(input.title.trim());
+  }
+  for (const sentence of extractNarrativeFacts(input.narrative)) {
+    derived.push(sentence);
+  }
+  const fileFact = buildFilesFact(input.filesModified);
+  if (fileFact) {
+    derived.push(fileFact);
+  }
+  return dedupeFacts(derived).slice(0, 4);
+}
+function extractNarrativeFacts(narrative) {
+  if (!narrative)
+    return [];
+  const cleaned = narrative.replace(/\s+/g, " ").trim();
+  if (cleaned.length < 24)
+    return [];
+  const parts = cleaned.split(/(?<=[.!?;])\s+/).map((part) => part.trim().replace(/[.!?;]+$/, "")).filter(Boolean).filter(looksMeaningful);
+  return parts.slice(0, 2);
+}
+function buildFilesFact(filesModified) {
+  if (!filesModified || filesModified.length === 0)
+    return null;
+  const cleaned = filesModified.map((file) => file.trim()).filter(Boolean).slice(0, 3);
+  if (cleaned.length === 0)
+    return null;
+  if (cleaned.length === 1) {
+    return `Touched ${cleaned[0]}`;
+  }
+  return `Touched ${cleaned.join(", ")}`;
+}
+function dedupeFacts(facts) {
+  const seen = new Set;
+  const result = [];
+  for (const fact of facts) {
+    const cleaned = fact.trim().replace(/\s+/g, " ");
+    if (!looksMeaningful(cleaned))
+      continue;
+    const key = cleaned.toLowerCase().replace(/\([^)]*\)/g, "").replace(/\s+/g, " ").trim();
+    if (!key || seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(cleaned);
+  }
+  return result;
+}
+function looksMeaningful(value) {
+  const cleaned = value.trim();
+  if (cleaned.length < 12)
+    return false;
+  if (/^[A-Za-z0-9_.\-\/]+\.[A-Za-z0-9]+$/.test(cleaned))
+    return false;
+  if (/^(updated|modified|edited|changed|touched)\s+[A-Za-z0-9_.\-\/]+$/i.test(cleaned))
+    return false;
+  return true;
+}
+
+// src/embeddings/embedder.ts
+var _available = null;
+var _pipeline = null;
+var MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
+async function embedText(text) {
+  const pipe = await getPipeline();
+  if (!pipe)
+    return null;
+  try {
+    const output = await pipe(text, { pooling: "mean", normalize: true });
+    return new Float32Array(output.data);
+  } catch {
+    return null;
+  }
+}
+function composeEmbeddingText(obs) {
+  const parts = [obs.title];
+  if (obs.narrative)
+    parts.push(obs.narrative);
+  if (obs.facts) {
+    try {
+      const facts = JSON.parse(obs.facts);
+      if (Array.isArray(facts) && facts.length > 0) {
+        parts.push(facts.map((f) => `- ${f}`).join(`
+`));
+      }
+    } catch {
+      parts.push(obs.facts);
+    }
+  }
+  if (obs.concepts) {
+    try {
+      const concepts = JSON.parse(obs.concepts);
+      if (Array.isArray(concepts) && concepts.length > 0) {
+        parts.push(concepts.join(", "));
+      }
+    } catch {}
+  }
+  return parts.join(`
+
+`);
+}
+async function getPipeline() {
+  if (_pipeline)
+    return _pipeline;
+  if (_available === false)
+    return null;
+  try {
+    const { pipeline } = await import("@xenova/transformers");
+    _pipeline = await pipeline("feature-extraction", MODEL_NAME);
+    _available = true;
+    return _pipeline;
+  } catch (err) {
+    _available = false;
+    console.error(`[engrm] Local embedding model unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+
+// src/capture/recurrence.ts
+var DISTANCE_THRESHOLD = 0.15;
+async function detectRecurrence(db, config, observation) {
+  if (observation.type !== "bugfix") {
+    return { patternCreated: false };
+  }
+  if (!db.vecAvailable) {
+    return { patternCreated: false };
+  }
+  const text = composeEmbeddingText(observation);
+  const embedding = await embedText(text);
+  if (!embedding) {
+    return { patternCreated: false };
+  }
+  const vecResults = db.searchVec(embedding, null, ["active", "aging", "pinned"], 10);
+  for (const match of vecResults) {
+    if (match.observation_id === observation.id)
+      continue;
+    if (match.distance > DISTANCE_THRESHOLD)
+      continue;
+    const matched = db.getObservationById(match.observation_id);
+    if (!matched)
+      continue;
+    if (matched.type !== "bugfix")
+      continue;
+    if (matched.session_id === observation.session_id)
+      continue;
+    if (await patternAlreadyExists(db, observation, matched))
+      continue;
+    let matchedProjectName;
+    if (matched.project_id !== observation.project_id) {
+      const proj = db.getProjectById(matched.project_id);
+      if (proj)
+        matchedProjectName = proj.name;
+    }
+    const similarity = 1 - match.distance;
+    const result = await saveObservation(db, config, {
+      type: "pattern",
+      title: `Recurring bugfix: ${observation.title}`,
+      narrative: `This bug pattern has appeared in multiple sessions. Original: "${matched.title}" (session ${matched.session_id?.slice(0, 8) ?? "unknown"}). Latest: "${observation.title}". Similarity: ${(similarity * 100).toFixed(0)}%. Consider addressing the root cause.`,
+      facts: [
+        `First seen: ${matched.created_at.split("T")[0]}`,
+        `Recurred: ${observation.created_at.split("T")[0]}`,
+        `Similarity: ${(similarity * 100).toFixed(0)}%`
+      ],
+      concepts: mergeConceptsFromBoth(observation, matched),
+      cwd: process.cwd(),
+      session_id: observation.session_id ?? undefined
+    });
+    if (result.success && result.observation_id) {
+      return {
+        patternCreated: true,
+        patternId: result.observation_id,
+        matchedObservationId: matched.id,
+        matchedProjectName,
+        matchedTitle: matched.title,
+        similarity
+      };
+    }
+  }
+  return { patternCreated: false };
+}
+async function patternAlreadyExists(db, obs1, obs2) {
+  const recentPatterns = db.db.query(`SELECT * FROM observations
+       WHERE type = 'pattern' AND lifecycle IN ('active', 'aging', 'pinned')
+       AND title LIKE ?
+       ORDER BY created_at_epoch DESC LIMIT 5`).all(`%${obs1.title.slice(0, 30)}%`);
+  for (const p of recentPatterns) {
+    if (p.narrative?.includes(obs2.title.slice(0, 30)))
+      return true;
+  }
+  return false;
+}
+function mergeConceptsFromBoth(obs1, obs2) {
+  const concepts = new Set;
+  for (const obs of [obs1, obs2]) {
+    if (obs.concepts) {
+      try {
+        const parsed = JSON.parse(obs.concepts);
+        if (Array.isArray(parsed)) {
+          for (const c of parsed) {
+            if (typeof c === "string")
+              concepts.add(c);
+          }
+        }
+      } catch {}
+    }
+  }
+  return [...concepts];
+}
+
+// src/capture/conflict.ts
+var SIMILARITY_THRESHOLD = 0.25;
+async function detectDecisionConflict(db, observation) {
+  if (observation.type !== "decision") {
+    return { hasConflict: false };
+  }
+  if (!observation.narrative || observation.narrative.trim().length < 20) {
+    return { hasConflict: false };
+  }
+  if (db.vecAvailable) {
+    return detectViaVec(db, observation);
+  }
+  return detectViaFts(db, observation);
+}
+async function detectViaVec(db, observation) {
+  const text = composeEmbeddingText(observation);
+  const embedding = await embedText(text);
+  if (!embedding)
+    return { hasConflict: false };
+  const results = db.searchVec(embedding, observation.project_id, ["active", "aging", "pinned"], 10);
+  for (const match of results) {
+    if (match.observation_id === observation.id)
+      continue;
+    if (match.distance > SIMILARITY_THRESHOLD)
+      continue;
+    const existing = db.getObservationById(match.observation_id);
+    if (!existing)
+      continue;
+    if (existing.type !== "decision")
+      continue;
+    if (!existing.narrative)
+      continue;
+    const conflict = narrativesConflict(observation.narrative, existing.narrative);
+    if (conflict) {
+      return {
+        hasConflict: true,
+        conflictingId: existing.id,
+        conflictingTitle: existing.title,
+        reason: conflict
+      };
+    }
+  }
+  return { hasConflict: false };
+}
+async function detectViaFts(db, observation) {
+  const keywords = observation.title.split(/\s+/).filter((w) => w.length > 3).slice(0, 5).join(" ");
+  if (!keywords)
+    return { hasConflict: false };
+  const ftsResults = db.searchFts(keywords, observation.project_id, ["active", "aging", "pinned"], 10);
+  for (const match of ftsResults) {
+    if (match.id === observation.id)
+      continue;
+    const existing = db.getObservationById(match.id);
+    if (!existing)
+      continue;
+    if (existing.type !== "decision")
+      continue;
+    if (!existing.narrative)
+      continue;
+    const conflict = narrativesConflict(observation.narrative, existing.narrative);
+    if (conflict) {
+      return {
+        hasConflict: true,
+        conflictingId: existing.id,
+        conflictingTitle: existing.title,
+        reason: conflict
+      };
+    }
+  }
+  return { hasConflict: false };
+}
+function narrativesConflict(narrative1, narrative2) {
+  const n1 = narrative1.toLowerCase();
+  const n2 = narrative2.toLowerCase();
+  const opposingPairs = [
+    [["should use", "decided to use", "chose", "prefer", "went with"], ["should not", "decided against", "avoid", "rejected", "don't use"]],
+    [["enable", "turn on", "activate", "add"], ["disable", "turn off", "deactivate", "remove"]],
+    [["increase", "more", "higher", "scale up"], ["decrease", "less", "lower", "scale down"]],
+    [["keep", "maintain", "preserve"], ["replace", "migrate", "switch from", "deprecate"]]
+  ];
+  for (const [positive, negative] of opposingPairs) {
+    const n1HasPositive = positive.some((w) => n1.includes(w));
+    const n1HasNegative = negative.some((w) => n1.includes(w));
+    const n2HasPositive = positive.some((w) => n2.includes(w));
+    const n2HasNegative = negative.some((w) => n2.includes(w));
+    if (n1HasPositive && n2HasNegative || n1HasNegative && n2HasPositive) {
+      return "Narratives suggest opposing conclusions on a similar topic";
+    }
+  }
+  return null;
+}
+
+// src/tools/save.ts
+var VALID_TYPES = [
+  "bugfix",
+  "discovery",
+  "decision",
+  "pattern",
+  "change",
+  "feature",
+  "refactor",
+  "digest",
+  "standard",
+  "message"
+];
+async function saveObservation(db, config, input) {
+  if (!VALID_TYPES.includes(input.type)) {
+    return {
+      success: false,
+      reason: `Invalid type '${input.type}'. Must be one of: ${VALID_TYPES.join(", ")}`
+    };
+  }
+  if (!input.title || input.title.trim().length === 0) {
+    return { success: false, reason: "Title is required" };
+  }
+  const cwd = input.cwd ?? process.cwd();
+  const touchedPaths = [...input.files_read ?? [], ...input.files_modified ?? []];
+  const detected = touchedPaths.length > 0 ? detectProjectFromTouchedPaths(touchedPaths, cwd) : detectProject(cwd);
+  const project = db.upsertProject({
+    canonical_id: detected.canonical_id,
+    name: detected.name,
+    local_path: detected.local_path,
+    remote_url: detected.remote_url
+  });
+  const customPatterns = config.scrubbing.enabled ? config.scrubbing.custom_patterns : [];
+  const title = config.scrubbing.enabled ? scrubSecrets(input.title, customPatterns) : input.title;
+  const narrative = input.narrative ? config.scrubbing.enabled ? scrubSecrets(input.narrative, customPatterns) : input.narrative : null;
+  const conceptsJson = input.concepts ? JSON.stringify(input.concepts) : null;
+  const filesRead = input.files_read ? input.files_read.map((f) => toRelativePath(f, cwd)) : null;
+  const filesModified = input.files_modified ? input.files_modified.map((f) => toRelativePath(f, cwd)) : null;
+  const structuredFacts = buildStructuredFacts({
+    type: input.type,
+    title: input.title,
+    narrative: input.narrative,
+    facts: input.facts,
+    filesModified
+  });
+  const factsJson = structuredFacts.length > 0 ? config.scrubbing.enabled ? scrubSecrets(JSON.stringify(structuredFacts), customPatterns) : JSON.stringify(structuredFacts) : null;
+  const filesReadJson = filesRead ? JSON.stringify(filesRead) : null;
+  const filesModifiedJson = filesModified ? JSON.stringify(filesModified) : null;
+  let sensitivity = input.sensitivity ?? config.scrubbing.default_sensitivity;
+  if (config.scrubbing.enabled && containsSecrets([input.title, input.narrative, JSON.stringify(input.facts)].filter(Boolean).join(" "), customPatterns)) {
+    if (sensitivity === "shared") {
+      sensitivity = "personal";
+    }
+  }
+  const oneDayAgo = Math.floor(Date.now() / 1000) - 86400;
+  const recentObs = db.getRecentObservations(project.id, oneDayAgo);
+  const candidates = recentObs.map((o) => ({
+    id: o.id,
+    title: o.title
+  }));
+  const duplicate = findDuplicate(title, candidates);
+  const qualityInput = {
+    type: input.type,
+    title,
+    narrative,
+    facts: factsJson,
+    concepts: conceptsJson,
+    filesRead,
+    filesModified,
+    isDuplicate: duplicate !== null
+  };
+  const qualityScore = scoreQuality(qualityInput);
+  if (!meetsQualityThreshold(qualityInput)) {
+    return {
+      success: false,
+      quality_score: qualityScore,
+      reason: `Quality score ${qualityScore.toFixed(2)} below threshold`
+    };
+  }
+  if (duplicate) {
+    return {
+      success: true,
+      merged_into: duplicate.id,
+      quality_score: qualityScore,
+      reason: `Merged into existing observation #${duplicate.id}`
+    };
+  }
+  const sourcePromptNumber = input.source_prompt_number ?? (input.session_id ? db.getLatestSessionPromptNumber(input.session_id) : null);
+  const obs = db.insertObservation({
+    session_id: input.session_id ?? null,
+    project_id: project.id,
+    type: input.type,
+    title,
+    narrative,
+    facts: factsJson,
+    concepts: conceptsJson,
+    files_read: filesReadJson,
+    files_modified: filesModifiedJson,
+    quality: qualityScore,
+    lifecycle: "active",
+    sensitivity,
+    user_id: config.user_id,
+    device_id: config.device_id,
+    agent: input.agent ?? "claude-code",
+    source_tool: input.source_tool ?? null,
+    source_prompt_number: sourcePromptNumber
+  });
+  db.addToOutbox("observation", obs.id);
+  if (db.vecAvailable) {
+    try {
+      const text = composeEmbeddingText(obs);
+      const embedding = await embedText(text);
+      if (embedding) {
+        db.vecInsert(obs.id, embedding);
+      }
+    } catch {}
+  }
+  let recallHint;
+  if (input.type === "bugfix") {
+    try {
+      const recurrence = await detectRecurrence(db, config, obs);
+      if (recurrence.patternCreated && recurrence.matchedTitle) {
+        const projectLabel = recurrence.matchedProjectName ? ` in ${recurrence.matchedProjectName}` : "";
+        recallHint = `You solved a similar issue${projectLabel}: "${recurrence.matchedTitle}"`;
+      }
+    } catch {}
+  }
+  let conflictWarning;
+  if (input.type === "decision") {
+    try {
+      const conflict = await detectDecisionConflict(db, obs);
+      if (conflict.hasConflict && conflict.conflictingTitle) {
+        conflictWarning = `Potential conflict with existing decision: "${conflict.conflictingTitle}" — ${conflict.reason}`;
+      }
+    } catch {}
+  }
+  return {
+    success: true,
+    observation_id: obs.id,
+    quality_score: qualityScore,
+    recall_hint: recallHint,
+    conflict_warning: conflictWarning
+  };
+}
+function toRelativePath(filePath, projectRoot) {
+  if (!isAbsolute(filePath))
+    return filePath;
+  const rel = relative(projectRoot, filePath);
+  if (rel.startsWith(".."))
+    return filePath;
+  return rel;
+}
+
+// src/tools/handoffs.ts
+function getRecentHandoffs(db, input) {
+  const limit = Math.max(1, Math.min(input.limit ?? 10, 25));
+  const projectScoped = input.project_scoped !== false;
+  let projectId = null;
+  let projectName;
+  if (projectScoped) {
+    const cwd = input.cwd ?? process.cwd();
+    const detected = detectProject(cwd);
+    const project = db.getProjectByCanonicalId(detected.canonical_id);
+    if (project) {
+      projectId = project.id;
+      projectName = project.name;
+    }
+  }
+  const conditions = [
+    "o.type = 'message'",
+    "o.lifecycle IN ('active', 'aging', 'pinned')",
+    "o.superseded_by IS NULL",
+    `(o.title LIKE 'Handoff:%' OR o.concepts LIKE '%"handoff"%')`
+  ];
+  const params = [];
+  if (input.user_id) {
+    conditions.push("(o.sensitivity != 'personal' OR o.user_id = ?)");
+    params.push(input.user_id);
+  }
+  if (projectId !== null) {
+    conditions.push("o.project_id = ?");
+    params.push(projectId);
+  }
+  params.push(limit);
+  const handoffs = db.db.query(`SELECT o.*, p.name AS project_name
+       FROM observations o
+       LEFT JOIN projects p ON p.id = o.project_id
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY o.created_at_epoch DESC, o.id DESC
+       LIMIT ?`).all(...params);
+  return {
+    handoffs,
+    project: projectName
+  };
+}
+
 // src/context/inject.ts
 function tokenizeProjectHint(text) {
   return Array.from(new Set((text.toLowerCase().match(/[a-z0-9_+-]{4,}/g) ?? []).filter(Boolean)));
@@ -619,6 +1342,12 @@ function buildSessionContext(db, cwd, options = {}) {
     const recentSessions2 = isNewProject ? [] : db.getRecentSessions(projectId, 5, opts.userId);
     const projectTypeCounts2 = isNewProject ? undefined : getProjectTypeCounts(db, projectId, opts.userId);
     const recentOutcomes2 = isNewProject ? undefined : getRecentOutcomes(db, projectId, opts.userId, recentSessions2);
+    const recentHandoffs2 = getRecentHandoffs(db, {
+      cwd,
+      project_scoped: !isNewProject,
+      user_id: opts.userId,
+      limit: 3
+    }).handoffs;
     return {
       project_name: projectName,
       canonical_id: canonicalId,
@@ -629,7 +1358,8 @@ function buildSessionContext(db, cwd, options = {}) {
       recentToolEvents: recentToolEvents2.length > 0 ? recentToolEvents2 : undefined,
       recentSessions: recentSessions2.length > 0 ? recentSessions2 : undefined,
       projectTypeCounts: projectTypeCounts2,
-      recentOutcomes: recentOutcomes2
+      recentOutcomes: recentOutcomes2,
+      recentHandoffs: recentHandoffs2.length > 0 ? recentHandoffs2 : undefined
     };
   }
   let remainingBudget = tokenBudget - 30;
@@ -657,6 +1387,12 @@ function buildSessionContext(db, cwd, options = {}) {
   const recentSessions = isNewProject ? [] : db.getRecentSessions(projectId, 5, opts.userId);
   const projectTypeCounts = isNewProject ? undefined : getProjectTypeCounts(db, projectId, opts.userId);
   const recentOutcomes = isNewProject ? undefined : getRecentOutcomes(db, projectId, opts.userId, recentSessions);
+  const recentHandoffs = getRecentHandoffs(db, {
+    cwd,
+    project_scoped: !isNewProject,
+    user_id: opts.userId,
+    limit: 3
+  }).handoffs;
   let securityFindings = [];
   if (!isNewProject) {
     try {
@@ -715,7 +1451,8 @@ function buildSessionContext(db, cwd, options = {}) {
     recentToolEvents: recentToolEvents.length > 0 ? recentToolEvents : undefined,
     recentSessions: recentSessions.length > 0 ? recentSessions : undefined,
     projectTypeCounts,
-    recentOutcomes
+    recentOutcomes,
+    recentHandoffs: recentHandoffs.length > 0 ? recentHandoffs : undefined
   };
 }
 function estimateObservationTokens(obs, index) {
@@ -1184,7 +1921,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync
 import { join as join3 } from "node:path";
 import { homedir } from "node:os";
 var STATE_PATH = join3(homedir(), ".engrm", "config-fingerprint.json");
-var CLIENT_VERSION = "0.4.21";
+var CLIENT_VERSION = "0.4.23";
 function hashFile(filePath) {
   try {
     if (!existsSync3(filePath))
@@ -1545,81 +2282,27 @@ function buildSourceId(config, localId, type = "obs") {
   return `${config.user_id}-${config.device_id}-${type}-${localId}`;
 }
 function parseSourceId(sourceId) {
-  const obsIndex = sourceId.lastIndexOf("-obs-");
-  if (obsIndex === -1)
-    return null;
-  const prefix = sourceId.slice(0, obsIndex);
-  const localIdStr = sourceId.slice(obsIndex + 5);
-  const localId = parseInt(localIdStr, 10);
-  if (isNaN(localId))
-    return null;
-  const firstDash = prefix.indexOf("-");
-  if (firstDash === -1)
-    return null;
-  return {
-    userId: prefix.slice(0, firstDash),
-    deviceId: prefix.slice(firstDash + 1),
-    localId
-  };
-}
-
-// src/embeddings/embedder.ts
-var _available = null;
-var _pipeline = null;
-var MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
-async function embedText(text) {
-  const pipe = await getPipeline();
-  if (!pipe)
-    return null;
-  try {
-    const output = await pipe(text, { pooling: "mean", normalize: true });
-    return new Float32Array(output.data);
-  } catch {
-    return null;
-  }
-}
-function composeEmbeddingText(obs) {
-  const parts = [obs.title];
-  if (obs.narrative)
-    parts.push(obs.narrative);
-  if (obs.facts) {
-    try {
-      const facts = JSON.parse(obs.facts);
-      if (Array.isArray(facts) && facts.length > 0) {
-        parts.push(facts.map((f) => `- ${f}`).join(`
-`));
-      }
-    } catch {
-      parts.push(obs.facts);
-    }
-  }
-  if (obs.concepts) {
-    try {
-      const concepts = JSON.parse(obs.concepts);
-      if (Array.isArray(concepts) && concepts.length > 0) {
-        parts.push(concepts.join(", "));
-      }
-    } catch {}
-  }
-  return parts.join(`
-
-`);
-}
-async function getPipeline() {
-  if (_pipeline)
-    return _pipeline;
-  if (_available === false)
-    return null;
-  try {
-    const { pipeline } = await import("@xenova/transformers");
-    _pipeline = await pipeline("feature-extraction", MODEL_NAME);
-    _available = true;
-    return _pipeline;
-  } catch (err) {
-    _available = false;
-    console.error(`[engrm] Local embedding model unavailable: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
+  for (const type of ["obs", "summary", "chat"]) {
+    const marker = `-${type}-`;
+    const idx = sourceId.lastIndexOf(marker);
+    if (idx === -1)
+      continue;
+    const prefix = sourceId.slice(0, idx);
+    const localIdStr = sourceId.slice(idx + marker.length);
+    const localId = parseInt(localIdStr, 10);
+    if (isNaN(localId))
+      return null;
+    const firstDash = prefix.indexOf("-");
+    if (firstDash === -1)
+      return null;
+    return {
+      userId: prefix.slice(0, firstDash),
+      deviceId: prefix.slice(firstDash + 1),
+      localId,
+      type
+    };
   }
+  return null;
 }
 
 // src/sync/pull.ts
@@ -1651,6 +2334,7 @@ function mergeChanges(db, config, changes) {
   for (const change of changes) {
     const parsed = parseSourceId(change.source_id);
     const remoteSummary = isRemoteSummary(change);
+    const remoteChat = isRemoteChat(change);
     if (parsed && parsed.deviceId === config.device_id) {
       skipped++;
       continue;
@@ -1673,6 +2357,15 @@ function mergeChanges(db, config, changes) {
         merged++;
       }
     }
+    if (remoteChat) {
+      const mergedChat = mergeRemoteChat(db, config, change, project.id);
+      if (mergedChat) {
+        merged++;
+      } else {
+        skipped++;
+      }
+      continue;
+    }
     const existing = db.db.query("SELECT id FROM observations WHERE remote_source_id = ?").get(change.source_id);
     if (existing) {
       if (!remoteSummary)
@@ -1714,6 +2407,10 @@ function isRemoteSummary(change) {
   const rawType = typeof change.metadata?.type === "string" ? change.metadata.type.toLowerCase() : "";
   return rawType === "summary" || change.source_id.includes("-summary-");
 }
+function isRemoteChat(change) {
+  const rawType = typeof change.metadata?.type === "string" ? change.metadata.type.toLowerCase() : "";
+  return rawType === "chat" || change.source_id.includes("-chat-");
+}
 function mergeRemoteSummary(db, config, change, projectId) {
   const sessionId = typeof change.metadata?.session_id === "string" ? change.metadata.session_id : null;
   if (!sessionId)
@@ -1727,6 +2424,7 @@ function mergeRemoteSummary(db, config, change, projectId) {
     learned: typeof change.metadata?.learned === "string" ? change.metadata.learned : null,
     completed: typeof change.metadata?.completed === "string" ? change.metadata.completed : null,
     next_steps: typeof change.metadata?.next_steps === "string" ? change.metadata.next_steps : null,
+    current_thread: typeof change.metadata?.current_thread === "string" ? change.metadata.current_thread : null,
     capture_state: typeof change.metadata?.capture_state === "string" ? change.metadata.capture_state : null,
     recent_tool_names: encodeStringArray(change.metadata?.recent_tool_names),
     hot_files: encodeStringArray(change.metadata?.hot_files),
@@ -1734,6 +2432,26 @@ function mergeRemoteSummary(db, config, change, projectId) {
   });
   return Boolean(summary);
 }
+function mergeRemoteChat(db, config, change, projectId) {
+  if (db.getChatMessageByRemoteSourceId(change.source_id))
+    return false;
+  const sessionId = typeof change.metadata?.session_id === "string" ? change.metadata.session_id : null;
+  const role = change.metadata?.role === "assistant" ? "assistant" : "user";
+  if (!sessionId || typeof change.content !== "string" || !change.content.trim())
+    return false;
+  db.insertChatMessage({
+    session_id: sessionId,
+    project_id: projectId,
+    role,
+    content: change.content,
+    user_id: (typeof change.metadata?.user_id === "string" ? change.metadata.user_id : null) ?? config.user_id,
+    device_id: (typeof change.metadata?.device_id === "string" ? change.metadata.device_id : null) ?? "remote",
+    agent: typeof change.metadata?.agent === "string" ? change.metadata.agent : "unknown",
+    created_at_epoch: typeof change.metadata?.created_at_epoch === "number" ? change.metadata.created_at_epoch : undefined,
+    remote_source_id: change.source_id
+  });
+  return true;
+}
 function encodeStringArray(value) {
   if (!Array.isArray(value))
     return null;
@@ -1993,7 +2711,7 @@ var MIGRATIONS = [
       -- Sync outbox (offline-first queue)
       CREATE TABLE sync_outbox (
           id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          record_type     TEXT NOT NULL CHECK (record_type IN ('observation', 'summary')),
+          record_type     TEXT NOT NULL CHECK (record_type IN ('observation', 'summary', 'chat_message')),
           record_id       INTEGER NOT NULL,
           status          TEXT DEFAULT 'pending' CHECK (status IN (
               'pending', 'syncing', 'synced', 'failed'
@@ -2288,6 +3006,18 @@ var MIGRATIONS = [
   },
   {
     version: 11,
+    description: "Add observation provenance from tool and prompt chronology",
+    sql: `
+      ALTER TABLE observations ADD COLUMN source_tool TEXT;
+      ALTER TABLE observations ADD COLUMN source_prompt_number INTEGER;
+      CREATE INDEX IF NOT EXISTS idx_observations_source_tool
+        ON observations(source_tool, created_at_epoch DESC);
+      CREATE INDEX IF NOT EXISTS idx_observations_source_prompt
+        ON observations(session_id, source_prompt_number DESC);
+    `
+  },
+  {
+    version: 12,
     description: "Add synced handoff metadata to session summaries",
     sql: `
       ALTER TABLE session_summaries ADD COLUMN capture_state TEXT;
@@ -2297,15 +3027,79 @@ var MIGRATIONS = [
     `
   },
   {
-    version: 11,
-    description: "Add observation provenance from tool and prompt chronology",
+    version: 13,
+    description: "Add current_thread to session summaries",
     sql: `
-      ALTER TABLE observations ADD COLUMN source_tool TEXT;
-      ALTER TABLE observations ADD COLUMN source_prompt_number INTEGER;
-      CREATE INDEX IF NOT EXISTS idx_observations_source_tool
-        ON observations(source_tool, created_at_epoch DESC);
-      CREATE INDEX IF NOT EXISTS idx_observations_source_prompt
-        ON observations(session_id, source_prompt_number DESC);
+      ALTER TABLE session_summaries ADD COLUMN current_thread TEXT;
+    `
+  },
+  {
+    version: 14,
+    description: "Add chat_messages lane for raw conversation recall",
+    sql: `
+      CREATE TABLE IF NOT EXISTS chat_messages (
+          id                INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id        TEXT NOT NULL,
+          project_id        INTEGER REFERENCES projects(id),
+          role              TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+          content           TEXT NOT NULL,
+          user_id           TEXT NOT NULL,
+          device_id         TEXT NOT NULL,
+          agent             TEXT DEFAULT 'claude-code',
+          created_at_epoch  INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chat_messages_session
+        ON chat_messages(session_id, created_at_epoch DESC, id DESC);
+      CREATE INDEX IF NOT EXISTS idx_chat_messages_project
+        ON chat_messages(project_id, created_at_epoch DESC, id DESC);
+      CREATE INDEX IF NOT EXISTS idx_chat_messages_created
+        ON chat_messages(created_at_epoch DESC, id DESC);
+    `
+  },
+  {
+    version: 15,
+    description: "Add remote_source_id for chat message sync deduplication",
+    sql: `
+      ALTER TABLE chat_messages ADD COLUMN remote_source_id TEXT;
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_messages_remote_source
+        ON chat_messages(remote_source_id)
+        WHERE remote_source_id IS NOT NULL;
+    `
+  },
+  {
+    version: 16,
+    description: "Allow chat_message records in sync_outbox",
+    sql: `
+      CREATE TABLE sync_outbox_new (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          record_type     TEXT NOT NULL CHECK (record_type IN ('observation', 'summary', 'chat_message')),
+          record_id       INTEGER NOT NULL,
+          status          TEXT DEFAULT 'pending' CHECK (status IN (
+              'pending', 'syncing', 'synced', 'failed'
+          )),
+          retry_count     INTEGER DEFAULT 0,
+          max_retries     INTEGER DEFAULT 10,
+          last_error      TEXT,
+          created_at_epoch INTEGER NOT NULL,
+          synced_at_epoch  INTEGER,
+          next_retry_epoch INTEGER
+      );
+
+      INSERT INTO sync_outbox_new (
+        id, record_type, record_id, status, retry_count, max_retries,
+        last_error, created_at_epoch, synced_at_epoch, next_retry_epoch
+      )
+      SELECT
+        id, record_type, record_id, status, retry_count, max_retries,
+        last_error, created_at_epoch, synced_at_epoch, next_retry_epoch
+      FROM sync_outbox;
+
+      DROP TABLE sync_outbox;
+      ALTER TABLE sync_outbox_new RENAME TO sync_outbox;
+
+      CREATE INDEX idx_outbox_status ON sync_outbox(status, next_retry_epoch);
+      CREATE INDEX idx_outbox_record ON sync_outbox(record_type, record_id);
     `
   }
 ];
@@ -2362,6 +3156,21 @@ function inferLegacySchemaVersion(db) {
     version = Math.max(version, 10);
   if (columnExists(db, "observations", "source_tool"))
     version = Math.max(version, 11);
+  if (columnExists(db, "session_summaries", "capture_state") && columnExists(db, "session_summaries", "recent_tool_names") && columnExists(db, "session_summaries", "hot_files") && columnExists(db, "session_summaries", "recent_outcomes")) {
+    version = Math.max(version, 12);
+  }
+  if (columnExists(db, "session_summaries", "current_thread")) {
+    version = Math.max(version, 13);
+  }
+  if (tableExists(db, "chat_messages")) {
+    version = Math.max(version, 14);
+  }
+  if (columnExists(db, "chat_messages", "remote_source_id")) {
+    version = Math.max(version, 15);
+  }
+  if (syncOutboxSupportsChatMessages(db)) {
+    version = Math.max(version, 16);
+  }
   return version;
 }
 function runMigrations(db) {
@@ -2440,6 +3249,93 @@ function ensureObservationTypes(db) {
     }
   }
 }
+function ensureSessionSummaryColumns(db) {
+  const required = [
+    "capture_state",
+    "recent_tool_names",
+    "hot_files",
+    "recent_outcomes",
+    "current_thread"
+  ];
+  for (const column of required) {
+    if (columnExists(db, "session_summaries", column))
+      continue;
+    db.exec(`ALTER TABLE session_summaries ADD COLUMN ${column} TEXT`);
+  }
+  const current = getSchemaVersion(db);
+  if (current < 13) {
+    db.exec("PRAGMA user_version = 13");
+  }
+}
+function ensureChatMessageColumns(db) {
+  if (!tableExists(db, "chat_messages"))
+    return;
+  if (!columnExists(db, "chat_messages", "remote_source_id")) {
+    db.exec("ALTER TABLE chat_messages ADD COLUMN remote_source_id TEXT");
+  }
+  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_messages_remote_source ON chat_messages(remote_source_id) WHERE remote_source_id IS NOT NULL");
+  const current = getSchemaVersion(db);
+  if (current < 15) {
+    db.exec("PRAGMA user_version = 15");
+  }
+}
+function ensureSyncOutboxSupportsChatMessages(db) {
+  if (syncOutboxSupportsChatMessages(db)) {
+    const current = getSchemaVersion(db);
+    if (current < 16) {
+      db.exec("PRAGMA user_version = 16");
+    }
+    return;
+  }
+  db.exec("BEGIN TRANSACTION");
+  try {
+    db.exec(`
+      CREATE TABLE sync_outbox_new (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          record_type     TEXT NOT NULL CHECK (record_type IN ('observation', 'summary', 'chat_message')),
+          record_id       INTEGER NOT NULL,
+          status          TEXT DEFAULT 'pending' CHECK (status IN (
+              'pending', 'syncing', 'synced', 'failed'
+          )),
+          retry_count     INTEGER DEFAULT 0,
+          max_retries     INTEGER DEFAULT 10,
+          last_error      TEXT,
+          created_at_epoch INTEGER NOT NULL,
+          synced_at_epoch  INTEGER,
+          next_retry_epoch INTEGER
+      );
+
+      INSERT INTO sync_outbox_new (
+        id, record_type, record_id, status, retry_count, max_retries,
+        last_error, created_at_epoch, synced_at_epoch, next_retry_epoch
+      )
+      SELECT
+        id, record_type, record_id, status, retry_count, max_retries,
+        last_error, created_at_epoch, synced_at_epoch, next_retry_epoch
+      FROM sync_outbox;
+
+      DROP TABLE sync_outbox;
+      ALTER TABLE sync_outbox_new RENAME TO sync_outbox;
+
+      CREATE INDEX idx_outbox_status ON sync_outbox(status, next_retry_epoch);
+      CREATE INDEX idx_outbox_record ON sync_outbox(record_type, record_id);
+    `);
+    db.exec("PRAGMA user_version = 16");
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw new Error(`sync_outbox repair failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function syncOutboxSupportsChatMessages(db) {
+  const row = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get("sync_outbox");
+  const sql = row?.sql ?? "";
+  return sql.includes("'chat_message'");
+}
+function getSchemaVersion(db) {
+  const result = db.query("PRAGMA user_version").get();
+  return result.user_version;
+}
 var LATEST_SCHEMA_VERSION = MIGRATIONS.filter((m) => !m.condition).reduce((max, m) => Math.max(max, m.version), 0);
 
 // src/storage/sqlite.ts
@@ -2514,6 +3410,9 @@ class MemDatabase {
     this.vecAvailable = this.loadVecExtension();
     runMigrations(this.db);
     ensureObservationTypes(this.db);
+    ensureSessionSummaryColumns(this.db);
+    ensureChatMessageColumns(this.db);
+    ensureSyncOutboxSupportsChatMessages(this.db);
   }
   loadVecExtension() {
     try {
@@ -2739,6 +3638,7 @@ class MemDatabase {
              p.name AS project_name,
              ss.request AS request,
              ss.completed AS completed,
+             ss.current_thread AS current_thread,
              ss.capture_state AS capture_state,
              ss.recent_tool_names AS recent_tool_names,
              ss.hot_files AS hot_files,
@@ -2757,6 +3657,7 @@ class MemDatabase {
            p.name AS project_name,
            ss.request AS request,
            ss.completed AS completed,
+           ss.current_thread AS current_thread,
            ss.capture_state AS capture_state,
            ss.recent_tool_names AS recent_tool_names,
            ss.hot_files AS hot_files,
@@ -2847,6 +3748,54 @@ class MemDatabase {
          ORDER BY created_at_epoch DESC, id DESC
          LIMIT ?`).all(...userId ? [userId] : [], limit);
   }
+  insertChatMessage(input) {
+    const createdAt = input.created_at_epoch ?? Math.floor(Date.now() / 1000);
+    const content = input.content.trim();
+    const result = this.db.query(`INSERT INTO chat_messages (
+          session_id, project_id, role, content, user_id, device_id, agent, created_at_epoch, remote_source_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.session_id, input.project_id, input.role, content, input.user_id, input.device_id, input.agent ?? "claude-code", createdAt, input.remote_source_id ?? null);
+    return this.getChatMessageById(Number(result.lastInsertRowid));
+  }
+  getChatMessageById(id) {
+    return this.db.query("SELECT * FROM chat_messages WHERE id = ?").get(id) ?? null;
+  }
+  getChatMessageByRemoteSourceId(remoteSourceId) {
+    return this.db.query("SELECT * FROM chat_messages WHERE remote_source_id = ?").get(remoteSourceId) ?? null;
+  }
+  getSessionChatMessages(sessionId, limit = 50) {
+    return this.db.query(`SELECT * FROM chat_messages
+         WHERE session_id = ?
+         ORDER BY created_at_epoch ASC, id ASC
+         LIMIT ?`).all(sessionId, limit);
+  }
+  getRecentChatMessages(projectId, limit = 20, userId) {
+    const visibilityClause = userId ? " AND user_id = ?" : "";
+    if (projectId !== null) {
+      return this.db.query(`SELECT * FROM chat_messages
+           WHERE project_id = ?${visibilityClause}
+           ORDER BY created_at_epoch DESC, id DESC
+           LIMIT ?`).all(projectId, ...userId ? [userId] : [], limit);
+    }
+    return this.db.query(`SELECT * FROM chat_messages
+         WHERE 1 = 1${visibilityClause}
+         ORDER BY created_at_epoch DESC, id DESC
+         LIMIT ?`).all(...userId ? [userId] : [], limit);
+  }
+  searchChatMessages(query, projectId, limit = 20, userId) {
+    const needle = `%${query.toLowerCase()}%`;
+    const visibilityClause = userId ? " AND user_id = ?" : "";
+    if (projectId !== null) {
+      return this.db.query(`SELECT * FROM chat_messages
+           WHERE project_id = ?
+             AND lower(content) LIKE ?${visibilityClause}
+           ORDER BY created_at_epoch DESC, id DESC
+           LIMIT ?`).all(projectId, needle, ...userId ? [userId] : [], limit);
+    }
+    return this.db.query(`SELECT * FROM chat_messages
+         WHERE lower(content) LIKE ?${visibilityClause}
+         ORDER BY created_at_epoch DESC, id DESC
+         LIMIT ?`).all(needle, ...userId ? [userId] : [], limit);
+  }
   addToOutbox(recordType, recordId) {
     const now = Math.floor(Date.now() / 1000);
     this.db.query(`INSERT INTO sync_outbox (record_type, record_id, created_at_epoch)
@@ -2935,9 +3884,9 @@ class MemDatabase {
     };
     const result = this.db.query(`INSERT INTO session_summaries (
           session_id, project_id, user_id, request, investigated, learned, completed, next_steps,
-          capture_state, recent_tool_names, hot_files, recent_outcomes, created_at_epoch
+          current_thread, capture_state, recent_tool_names, hot_files, recent_outcomes, created_at_epoch
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(summary.session_id, summary.project_id, summary.user_id, normalized.request, normalized.investigated, normalized.learned, normalized.completed, normalized.next_steps, summary.capture_state ?? null, summary.recent_tool_names ?? null, summary.hot_files ?? null, summary.recent_outcomes ?? null, now);
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(summary.session_id, summary.project_id, summary.user_id, normalized.request, normalized.investigated, normalized.learned, normalized.completed, normalized.next_steps, summary.current_thread ?? null, summary.capture_state ?? null, summary.recent_tool_names ?? null, summary.hot_files ?? null, summary.recent_outcomes ?? null, now);
     const id = Number(result.lastInsertRowid);
     return this.db.query("SELECT * FROM session_summaries WHERE id = ?").get(id);
   }
@@ -2953,6 +3902,7 @@ class MemDatabase {
       learned: normalizeSummarySection(summary.learned ?? existing.learned),
       completed: normalizeSummarySection(summary.completed ?? existing.completed),
       next_steps: normalizeSummarySection(summary.next_steps ?? existing.next_steps),
+      current_thread: summary.current_thread ?? existing.current_thread,
       capture_state: summary.capture_state ?? existing.capture_state,
       recent_tool_names: summary.recent_tool_names ?? existing.recent_tool_names,
       hot_files: summary.hot_files ?? existing.hot_files,
@@ -2966,12 +3916,13 @@ class MemDatabase {
              learned = ?,
              completed = ?,
              next_steps = ?,
+             current_thread = ?,
              capture_state = ?,
              recent_tool_names = ?,
              hot_files = ?,
              recent_outcomes = ?,
              created_at_epoch = ?
-         WHERE session_id = ?`).run(summary.project_id ?? existing.project_id, summary.user_id, normalized.request, normalized.investigated, normalized.learned, normalized.completed, normalized.next_steps, normalized.capture_state, normalized.recent_tool_names, normalized.hot_files, normalized.recent_outcomes, now, summary.session_id);
+         WHERE session_id = ?`).run(summary.project_id ?? existing.project_id, summary.user_id, normalized.request, normalized.investigated, normalized.learned, normalized.completed, normalized.next_steps, normalized.current_thread, normalized.capture_state, normalized.recent_tool_names, normalized.hot_files, normalized.recent_outcomes, now, summary.session_id);
     return this.getSessionSummary(summary.session_id);
   }
   getSessionSummary(sessionId) {
@@ -3307,8 +4258,17 @@ function formatVisibleStartupBrief(context) {
   const toolFallbacks = buildToolFallbacks(context);
   const sessionFallbacks = sessionFallbacksFromContext(context);
   const recentOutcomeLines = buildRecentOutcomeLines(context, latest);
+  const currentThread = buildCurrentThreadLine(context, latest);
   const projectSignals = buildProjectSignalLine(context);
   const shownItems = new Set;
+  const latestHandoffLines = buildLatestHandoffLines(context);
+  if (latestHandoffLines.length > 0) {
+    lines.push(`${c2.cyan}Latest handoff:${c2.reset}`);
+    for (const item of latestHandoffLines) {
+      lines.push(`  - ${truncateInline(item, 160)}`);
+      rememberShownItem(shownItems, item);
+    }
+  }
   if (promptLines.length > 0) {
     lines.push(`${c2.cyan}Asked recently:${c2.reset}`);
     for (const item of promptLines) {
@@ -3356,6 +4316,11 @@ function formatVisibleStartupBrief(context) {
       }
     }
   }
+  if (currentThread && !shownItems.has(normalizeStartupItem(currentThread))) {
+    lines.push(`${c2.cyan}Current thread:${c2.reset}`);
+    lines.push(`  - ${truncateInline(currentThread, 160)}`);
+    rememberShownItem(shownItems, currentThread);
+  }
   if (latest && currentRequest && !hasRequestSection(lines) && !duplicatesPromptLine(currentRequest, latestPromptLine)) {
     lines.push(`${c2.cyan}What you're on:${c2.reset}`);
     lines.push(`  - ${truncateInline(currentRequest, 160)}`);
@@ -3400,6 +4365,20 @@ function formatVisibleStartupBrief(context) {
   }
   return lines.slice(0, 14);
 }
+function buildLatestHandoffLines(context) {
+  const latest = context.recentHandoffs?.[0];
+  if (!latest)
+    return [];
+  const lines = [];
+  const title = latest.title.replace(/^Handoff:\s*/i, "").replace(/\s+\u00B7\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}Z$/, "").trim();
+  if (title)
+    lines.push(title);
+  const narrative = latest.narrative?.split(/\n{2,}/).map((part) => part.replace(/\s+/g, " ").trim()).find((part) => /^(Current thread:|Completed:|Next Steps:)/i.test(part));
+  if (narrative) {
+    lines.push(narrative.replace(/^(Current thread:|Completed:|Next Steps:)\s*/i, ""));
+  }
+  return Array.from(new Set(lines.filter(Boolean))).slice(0, 2);
+}
 function formatContextEconomics(data) {
   const totalMemories = Math.max(0, data.loaded + data.available);
   const parts = [];
@@ -3443,6 +4422,7 @@ function formatInspectHints(context, visibleObservationIds = []) {
   if ((context.recentSessions?.length ?? 0) > 0) {
     hints.push("recent_sessions");
     hints.push("session_story");
+    hints.push("create_handoff");
   }
   if ((context.recentPrompts?.length ?? 0) > 0 || (context.recentToolEvents?.length ?? 0) > 0) {
     hints.push("activity_feed");
@@ -3450,6 +4430,9 @@ function formatInspectHints(context, visibleObservationIds = []) {
   if (context.observations.length > 0) {
     hints.push("memory_console");
   }
+  if ((context.recentSessions?.length ?? 0) > 0) {
+    hints.push("recent_handoffs");
+  }
   const unique = Array.from(new Set(hints)).slice(0, 4);
   if (unique.length === 0)
     return [];
@@ -3582,6 +4565,22 @@ function buildRecentOutcomeLines(context, summary) {
   }
   return picked;
 }
+function buildCurrentThreadLine(context, summary) {
+  const explicit = summary?.current_thread ?? null;
+  if (explicit && !looksLikeFileOperationTitle2(explicit))
+    return explicit;
+  for (const session of context.recentSessions ?? []) {
+    if (session.current_thread && !looksLikeFileOperationTitle2(session.current_thread)) {
+      return session.current_thread;
+    }
+  }
+  const request = buildPromptFallback(context);
+  const outcome = buildRecentOutcomeLines(context, summary)[0] ?? null;
+  const tool = buildToolFallbacks(context)[0] ?? null;
+  if (outcome && tool)
+    return `${outcome} \xB7 ${tool}`;
+  return outcome ?? request ?? null;
+}
 function chooseMeaningfulSessionSummary(request, completed) {
   if (request && !looksLikeFileOperationTitle2(request))
     return request;
@@ -3833,7 +4832,15 @@ function isWeakCompletedSection(value) {
   return weakCount === items.length;
 }
 function looksLikeFileOperationTitle2(value) {
-  return /^(modified|updated|edited|touched|changed|extended|refactored|redesigned)\s+[A-Za-z0-9_.\-\/]+(?:\s*\([^)]*\))?$/i.test(value.trim());
+  const trimmed = value.trim();
+  if (/^(modified|updated|edited|touched|changed|extended|refactored|redesigned)\s+[A-Za-z0-9_.\-\/]+(?:\s*\([^)]*\))?$/i.test(trimmed)) {
+    return true;
+  }
+  return looksLikeGenericSummaryWrapper(trimmed);
+}
+function looksLikeGenericSummaryWrapper(value) {
+  const normalized = value.toLowerCase().replace(/\s+/g, " ").trim();
+  return normalized.startsWith("all clean. here's a summary of what was fixed") || normalized.startsWith("all clean, here's a summary of what was fixed") || normalized.startsWith("now i have enough to give a clear, accurate assessment") || normalized.startsWith("here's the real picture") || normalized === "event log \u2192 existing events feed" || normalized.startsWith("event log -> existing events feed") || normalized.startsWith("tl;dr:");
 }
 function scoreSplashLine(value) {
   let score = 0;