engrm 0.3.4 → 0.4.0

package/dist/hooks/stop.js

@@ -4,9 +4,9 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, hostname } from "node:os";
+import { homedir, hostname, networkInterfaces } from "node:os";
 import { join } from "node:path";
-import { randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 var CONFIG_DIR = join(homedir(), ".engrm");
 var SETTINGS_PATH = join(CONFIG_DIR, "settings.json");
 var DB_PATH = join(CONFIG_DIR, "engrm.db");
@@ -15,7 +15,22 @@ function getDbPath() {
 }
 function generateDeviceId() {
   const host = hostname().toLowerCase().replace(/[^a-z0-9-]/g, "");
-  const suffix = randomBytes(4).toString("hex");
+  let mac = "";
+  const ifaces = networkInterfaces();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
+        mac = entry.mac;
+        break;
+      }
+    }
+    if (mac)
+      break;
+  }
+  const material = `${host}:${mac || "no-mac"}`;
+  const suffix = createHash("sha256").update(material).digest("hex").slice(0, 8);
   return `${host}-${suffix}`;
 }
 function createDefaultConfig() {
@@ -57,7 +72,10 @@ function createDefaultConfig() {
     observer: {
       enabled: true,
       mode: "per_event",
-      model: "haiku"
+      model: "sonnet"
+    },
+    transcript_analysis: {
+      enabled: false
     }
   };
 }
@@ -116,9 +134,19 @@ function loadConfig() {
       enabled: asBool(config["observer"]?.["enabled"], defaults.observer.enabled),
       mode: asObserverMode(config["observer"]?.["mode"], defaults.observer.mode),
       model: asString(config["observer"]?.["model"], defaults.observer.model)
+    },
+    transcript_analysis: {
+      enabled: asBool(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
     }
   };
 }
+function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(SETTINGS_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
 function configExists() {
   return existsSync(SETTINGS_PATH);
 }
@@ -1254,6 +1282,13 @@ class VectorClient {
   async sendTelemetry(beacon) {
     await this.request("POST", "/v1/mem/telemetry", beacon);
   }
+  async fetchSettings() {
+    try {
+      return await this.request("GET", "/v1/mem/user-settings");
+    } catch {
+      return null;
+    }
+  }
   async health() {
     try {
       await this.request("GET", "/health");
@@ -1353,6 +1388,7 @@ function buildVectorDocument(obs, config, project) {
       project_name: project.name,
       user_id: obs.user_id,
       device_id: obs.device_id,
+      device_name: __require("node:os").hostname(),
       agent: obs.agent,
       title: obs.title,
       narrative: obs.narrative,
@@ -1481,6 +1517,105 @@ async function pushOutbox(db, client, config, batchSize = 50) {
   return { pushed, failed, skipped };
 }
 
+// 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/sync/pull.ts
+async function pullSettings(client, config) {
+  try {
+    const settings = await client.fetchSettings();
+    if (!settings)
+      return false;
+    let changed = false;
+    if (settings.transcript_analysis !== undefined) {
+      const ta = settings.transcript_analysis;
+      if (typeof ta === "object" && ta !== null) {
+        const taObj = ta;
+        if (taObj.enabled !== undefined && taObj.enabled !== config.transcript_analysis.enabled) {
+          config.transcript_analysis.enabled = !!taObj.enabled;
+          changed = true;
+        }
+      }
+    }
+    if (settings.observer !== undefined) {
+      const obs = settings.observer;
+      if (typeof obs === "object" && obs !== null) {
+        const obsObj = obs;
+        if (obsObj.enabled !== undefined && obsObj.enabled !== config.observer.enabled) {
+          config.observer.enabled = !!obsObj.enabled;
+          changed = true;
+        }
+        if (obsObj.model !== undefined && typeof obsObj.model === "string" && obsObj.model !== config.observer.model) {
+          config.observer.model = obsObj.model;
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      saveConfig(config);
+    }
+    return changed;
+  } catch {
+    return false;
+  }
+}
+
 // src/sync/push-once.ts
 async function pushOnce(db, config) {
   if (!config.sync.enabled)
@@ -1490,6 +1625,7 @@ async function pushOnce(db, config) {
   try {
     const client = new VectorClient(config);
     const result = await pushOutbox(db, client, config, config.sync.batch_size);
+    await pullSettings(client, config);
     return result.pushed;
   } catch {
     return 0;
@@ -1719,6 +1855,702 @@ function detectProject(directory) {
   };
 }
 
+// src/capture/transcript.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// 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;
+  }
+  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/dedup.ts
+function tokenise(text) {
+  const cleaned = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim();
+  const tokens = cleaned.split(/\s+/).filter((t) => t.length > 0);
+  return new Set(tokens);
+}
+function jaccardSimilarity(a, b) {
+  const tokensA = tokenise(a);
+  const tokensB = tokenise(b);
+  if (tokensA.size === 0 && tokensB.size === 0)
+    return 1;
+  if (tokensA.size === 0 || tokensB.size === 0)
+    return 0;
+  let intersectionSize = 0;
+  for (const token of tokensA) {
+    if (tokensB.has(token))
+      intersectionSize++;
+  }
+  const unionSize = tokensA.size + tokensB.size - intersectionSize;
+  if (unionSize === 0)
+    return 0;
+  return intersectionSize / unionSize;
+}
+var DEDUP_THRESHOLD = 0.8;
+function findDuplicate(newTitle, candidates) {
+  let bestMatch = null;
+  let bestScore = 0;
+  for (const candidate of candidates) {
+    const similarity = jaccardSimilarity(newTitle, candidate.title);
+    if (similarity > DEDUP_THRESHOLD && similarity > bestScore) {
+      bestScore = similarity;
+      bestMatch = candidate;
+    }
+  }
+  return bestMatch;
+}
+
+// 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 detected = 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 factsJson = input.facts ? config.scrubbing.enabled ? scrubSecrets(JSON.stringify(input.facts), customPatterns) : JSON.stringify(input.facts) : 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 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 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"
+  });
+  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/capture/transcript.ts
+function resolveTranscriptPath(sessionId, cwd) {
+  const encodedCwd = cwd.replace(/\//g, "-");
+  return join4(homedir2(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
+}
+function readTranscript(sessionId, cwd) {
+  const path = resolveTranscriptPath(sessionId, cwd);
+  if (!existsSync3(path))
+    return [];
+  let raw;
+  try {
+    raw = readFileSync3(path, "utf-8");
+  } catch {
+    return [];
+  }
+  const messages = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const role = entry.role;
+    if (role !== "user" && role !== "assistant")
+      continue;
+    const content = entry.content;
+    if (typeof content === "string") {
+      messages.push({ role, text: content });
+      continue;
+    }
+    if (Array.isArray(content)) {
+      const textParts = [];
+      for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          textParts.push(block.text);
+        }
+      }
+      if (textParts.length > 0) {
+        messages.push({ role, text: textParts.join(`
+`) });
+      }
+    }
+  }
+  return messages;
+}
+function truncateTranscript(messages, maxBytes = 50000) {
+  const lines = [];
+  for (const msg of messages) {
+    lines.push(`[${msg.role}]: ${msg.text}`);
+  }
+  const full = lines.join(`
+`);
+  if (Buffer.byteLength(full, "utf-8") <= maxBytes)
+    return full;
+  let result = "";
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const candidate = lines[i] + `
+` + result;
+    if (Buffer.byteLength(candidate, "utf-8") > maxBytes)
+      break;
+    result = candidate;
+  }
+  return result.trim();
+}
+async function analyzeTranscript(config, transcript, sessionId) {
+  if (!config.candengo_url || !config.candengo_api_key)
+    return null;
+  const url = `${config.candengo_url}/v1/mem/transcript-analysis`;
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), 30000);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.candengo_api_key}`
+      },
+      body: JSON.stringify({
+        transcript,
+        session_id: sessionId
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    if (!Array.isArray(data.plans) || !Array.isArray(data.decisions) || !Array.isArray(data.insights)) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function saveTranscriptResults(db, config, results, sessionId, cwd) {
+  let saved = 0;
+  const items = [
+    ...results.plans.map((item) => ({ item, type: "decision" })),
+    ...results.decisions.map((item) => ({ item, type: "decision" })),
+    ...results.insights.map((item) => ({ item, type: "discovery" }))
+  ];
+  for (const { item, type } of items) {
+    if (!item.title || item.title.trim().length === 0)
+      continue;
+    const result = await saveObservation(db, config, {
+      type,
+      title: item.title.slice(0, 80),
+      narrative: item.narrative,
+      concepts: item.concepts,
+      session_id: sessionId,
+      cwd
+    });
+    if (result.success)
+      saved++;
+  }
+  return saved;
+}
+
 // hooks/stop.ts
 function printRetrospective(summary) {
   const lines = [];
@@ -1828,6 +2660,22 @@ async function main() {
         createSessionDigest(db, event.session_id, event.cwd);
       } catch {}
     }
+    if (config.transcript_analysis?.enabled && event.session_id) {
+      try {
+        const messages = readTranscript(event.session_id, event.cwd);
+        if (messages.length > 10) {
+          const transcript = truncateTranscript(messages);
+          const results = await analyzeTranscript(config, transcript, event.session_id);
+          if (results) {
+            const saved = await saveTranscriptResults(db, config, results, event.session_id, event.cwd);
+            if (saved > 0) {
+              console.error(`
+\uD83D\uDCA1 Engrm: Extracted ${saved} insight(s) from session transcript.`);
+            }
+          }
+        }
+      } catch {}
+    }
     await pushOnce(db, config);
     try {
       if (event.session_id) {