nexusmem 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -2,13 +2,68 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import pc13 from "picocolors";
+import pc14 from "picocolors";
 
 // src/config/workspace.ts
 import { existsSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { z } from "zod";
+
+// src/slm/provider.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:11434";
+var DEFAULT_SLM_MODEL = "qwen2.5:3b";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_TOKENS = 400;
+var OllamaChatProvider = class {
+  identity;
+  baseUrl;
+  model;
+  timeoutMs;
+  maxTokens;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.model = opts.model ?? DEFAULT_SLM_MODEL;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.identity = `ollama:${this.model}`;
+  }
+  async complete(prompt) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(`${this.baseUrl}/api/generate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          prompt,
+          stream: false,
+          options: {
+            // Deterministic: the same session must summarize to the same text
+            // across syncs, or the content hash that suppresses re-work would
+            // never match and every sync would rewrite every summary node.
+            temperature: 0,
+            seed: 1,
+            num_predict: this.maxTokens
+          }
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (typeof data.response !== "string") return null;
+      const text = data.response.trim();
+      return text.length > 0 ? text : null;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/config/workspace.ts
 var WORKSPACE_DIR = ".nexusmem";
 function resolveWorkspace(repoRoot) {
   const dir = join(repoRoot, WORKSPACE_DIR);
@@ -46,6 +101,32 @@ var ConfigSchema = z.object({
     conversation: z.object({
       enabled: z.boolean().default(false)
     }).default({ enabled: false }),
+    /**
+     * One distilled node per finished working session, written by a local
+     * small language model.
+     *
+     * Opt-in for the same reason as `conversation` -- it reads the same
+     * transcripts -- and additionally because it is the only source that
+     * costs real compute. Independent of `conversation.enabled`: summaries
+     * without the raw exchanges is a legitimate, and much smaller, way to
+     * remember a session.
+     */
+    session: z.object({
+      enabled: z.boolean().default(false),
+      /** Ollama model tag. Must be pulled locally; nothing is downloaded automatically. */
+      model: z.string().default(DEFAULT_SLM_MODEL),
+      /** Minutes of quiet before a session counts as finished and can be summarized. */
+      settleMinutes: z.number().int().nonnegative().default(30),
+      /** Sessions summarized per sync. Each is a model call measured in seconds. */
+      maxSessions: z.number().int().positive().default(10),
+      maxPromptChars: z.number().int().positive().default(12e3)
+    }).default({
+      enabled: false,
+      model: DEFAULT_SLM_MODEL,
+      settleMinutes: 30,
+      maxSessions: 10,
+      maxPromptChars: 12e3
+    }),
     /** Tracked `.md` files -- README, architecture docs. On by default like git/shell: no secrets risk, just project prose. */
     docs: z.object({
       enabled: z.boolean().default(true),
@@ -71,6 +152,13 @@ var ConfigSchema = z.object({
     git: { enabled: true, since: null, includeMerges: true },
     shell: { enabled: true, tailLines: 300 },
     conversation: { enabled: false },
+    session: {
+      enabled: false,
+      model: DEFAULT_SLM_MODEL,
+      settleMinutes: 30,
+      maxSessions: 10,
+      maxPromptChars: 12e3
+    },
     docs: { enabled: true, include: ["*.md"] },
     diff: { enabled: true, maxCommits: 200, maxFilesPerCommit: 20, contextLines: 3 }
   }),
@@ -209,9 +297,9 @@ async function* gitStream(cwd, args, opts = {}) {
   for (let attempt = 0; ; attempt += 1) {
     let produced = false;
     try {
-      for await (const chunk of runGitOnce(cwd, args, opts)) {
+      for await (const chunk2 of runGitOnce(cwd, args, opts)) {
         produced = true;
-        yield chunk;
+        yield chunk2;
       }
       return;
     } catch (err) {
@@ -227,8 +315,8 @@ async function* runGitOnce(cwd, args, opts) {
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
   let stderr = "";
-  child.stderr.on("data", (chunk) => {
-    if (stderr.length < 64 * 1024) stderr += chunk;
+  child.stderr.on("data", (chunk2) => {
+    if (stderr.length < 64 * 1024) stderr += chunk2;
   });
   const exited = new Promise((resolve2, reject) => {
     child.once("error", (err) => reject(toSpawnError(err, cwd, fullArgs)));
@@ -237,8 +325,8 @@ async function* runGitOnce(cwd, args, opts) {
   exited.catch(() => {
   });
   try {
-    for await (const chunk of child.stdout) {
-      yield chunk;
+    for await (const chunk2 of child.stdout) {
+      yield chunk2;
     }
   } finally {
     if (child.exitCode === null) child.kill();
@@ -267,7 +355,7 @@ async function* runGitOnce(cwd, args, opts) {
 }
 async function git(cwd, args, opts = {}) {
   let out = "";
-  for await (const chunk of gitStream(cwd, args, opts)) out += chunk;
+  for await (const chunk2 of gitStream(cwd, args, opts)) out += chunk2;
   return out;
 }
 async function gitOrNull(cwd, args, opts = {}) {
@@ -831,6 +919,20 @@ var MemoryStore = class _MemoryStore {
     run(nodes);
     return stats;
   }
+  /**
+   * The stored `meta` blob for one node, or null if it has never been
+   * written. Used by the session summarizer to recognise work it has
+   * already done without re-reading the node's whole body.
+   */
+  getNodeMeta(id) {
+    const row = this.db.prepare("SELECT meta FROM nodes WHERE id = ?").get(id);
+    if (!row) return null;
+    try {
+      return JSON.parse(row.meta);
+    } catch {
+      return null;
+    }
+  }
   getSyncCursor(projectId, source) {
     const row = this.db.prepare("SELECT cursor FROM sync_state WHERE project_id = ? AND source = ?").get(projectId, source);
     return row?.cursor ?? null;
@@ -893,19 +995,57 @@ var MemoryStore = class _MemoryStore {
       return this.db.prepare(`DELETE FROM nodes WHERE ${scope}`).run(params).changes;
     })();
   }
-  /** Nodes for this project that have no embedding yet (new, or invalidated by a content change). */
-  findNodesNeedingEmbedding(projectId, limit = 200) {
+  /**
+   * Nodes for this project that have no embedding yet (new, or invalidated
+   * by a content change).
+   *
+   * `afterRowid` makes paging monotonic: the pass walks rowids strictly
+   * upward instead of re-reading "the first N still pending". That matters
+   * because a node the provider *failed* on stays pending -- an offset-free
+   * loop would fetch the same failures forever, which is exactly the shape
+   * of an infinite sync.
+   */
+  findNodesNeedingEmbedding(projectId, limit = 200, afterRowid = 0) {
     return this.db.prepare(
       `SELECT n.rowid AS rowid, n.id AS id, n.title AS title, n.body AS body
          FROM nodes n
          LEFT JOIN nodes_vec v ON v.rowid = n.rowid
-         WHERE n.project_id = ? AND v.rowid IS NULL
+         WHERE n.project_id = ? AND v.rowid IS NULL AND n.rowid > ?
+         ORDER BY n.rowid
          LIMIT ?`
-    ).all(projectId, limit);
+    ).all(projectId, afterRowid, limit);
+  }
+  /** How many of this project's nodes still need a vector. For progress reporting. */
+  countNodesNeedingEmbedding(projectId) {
+    const row = this.db.prepare(
+      `SELECT COUNT(*) AS n
+         FROM nodes n
+         LEFT JOIN nodes_vec v ON v.rowid = n.rowid
+         WHERE n.project_id = ? AND v.rowid IS NULL`
+    ).get(projectId);
+    return row.n;
   }
   upsertEmbedding(rowid, embedding) {
     this.db.prepare("INSERT OR REPLACE INTO nodes_vec (rowid, embedding) VALUES (?, ?)").run(BigInt(rowid), embedding);
   }
+  /**
+   * Drop every vector in this database, across all projects.
+   *
+   * Whole-database on purpose: `nodes_vec` is shared and holds no
+   * provenance, so once the vectors in it stopped being comparable there is
+   * no subset that is still trustworthy. Nodes are untouched, so the next
+   * embedding pass simply rebuilds them.
+   */
+  dropAllEmbeddings() {
+    return this.db.prepare("DELETE FROM nodes_vec").run().changes;
+  }
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
   /**
    * Nearest-neighbour search over the corpus.
    *
@@ -970,7 +1110,7 @@ var MemoryStore = class _MemoryStore {
 
 // src/cli/commands/init.ts
 async function runInit(opts) {
-  const out = opts.out ?? ((chunk) => void process.stdout.write(chunk));
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
   const repo = await readRepoInfo(opts.cwd);
   const ws = resolveWorkspace(repo.root);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
@@ -1091,7 +1231,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z3 } from "zod";
 
 // src/mcp/tools.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 
 // src/core/text.ts
 function truncate(s, max) {
@@ -1291,8 +1431,10 @@ var RECENCY_FLOOR = 0.3;
 var DEFAULT_HALF_LIFE_DAYS = 30;
 var MS_PER_DAY = 864e5;
 var MAX_PRIOR_OVERTURN = 2;
-var SIGNAL_EXPONENT = Math.log(MAX_PRIOR_OVERTURN) / Math.log(1 / SIGNAL_FLOOR);
-var RECENCY_EXPONENT = Math.log(MAX_PRIOR_OVERTURN) / Math.log(1 / RECENCY_FLOOR);
+var PRIOR_COUNT = 2;
+var PER_PRIOR_OVERTURN = MAX_PRIOR_OVERTURN ** (1 / PRIOR_COUNT);
+var SIGNAL_EXPONENT = Math.log(PER_PRIOR_OVERTURN) / Math.log(1 / SIGNAL_FLOOR);
+var RECENCY_EXPONENT = Math.log(PER_PRIOR_OVERTURN) / Math.log(1 / RECENCY_FLOOR);
 function normalizeRelevance(hits) {
   const costs = hits.map((h) => h.rank);
   const min = Math.min(...costs);
@@ -1420,37 +1562,52 @@ function labelProjects(projects) {
 }
 
 // src/vector/embed.ts
-var DEFAULT_BASE_URL = "http://127.0.0.1:11434";
+var DEFAULT_BASE_URL2 = "http://127.0.0.1:11434";
 var DEFAULT_MODEL = "nomic-embed-text";
 var DEFAULT_DIMENSION = 768;
-var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+var DEFAULT_MAX_TIMEOUT_MS = 12e4;
+var EMBED_PATH = "/api/embed";
 var OllamaEmbeddingProvider = class {
   dimension;
+  identity;
   baseUrl;
   model;
   timeoutMs;
+  maxTimeoutMs;
   constructor(opts = {}) {
-    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL2;
     this.model = opts.model ?? DEFAULT_MODEL;
     this.dimension = opts.dimension ?? DEFAULT_DIMENSION;
-    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    this.maxTimeoutMs = opts.maxTimeoutMs ?? DEFAULT_MAX_TIMEOUT_MS;
+    this.identity = `ollama${EMBED_PATH}:${this.model}:${this.dimension}`;
   }
   async embed(text) {
+    const [only] = await this.embedBatch([text]);
+    return only ?? null;
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) return [];
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const budget = Math.min(this.timeoutMs * texts.length, this.maxTimeoutMs);
+    const timeout = setTimeout(() => controller.abort(), budget);
     try {
-      const res = await fetch(`${this.baseUrl}/api/embeddings`, {
+      const res = await fetch(`${this.baseUrl}${EMBED_PATH}`, {
         method: "POST",
         headers: { "content-type": "application/json" },
-        body: JSON.stringify({ model: this.model, prompt: text }),
+        body: JSON.stringify({ model: this.model, input: texts }),
         signal: controller.signal
       });
-      if (!res.ok) return null;
+      if (!res.ok) return texts.map(() => null);
       const data = await res.json();
-      if (!Array.isArray(data.embedding) || data.embedding.length !== this.dimension) return null;
-      return new Float32Array(data.embedding);
+      if (!Array.isArray(data.embeddings)) return texts.map(() => null);
+      if (data.embeddings.length !== texts.length) return texts.map(() => null);
+      return data.embeddings.map(
+        (row) => Array.isArray(row) && row.length === this.dimension ? new Float32Array(row) : null
+      );
     } catch {
-      return null;
+      return texts.map(() => null);
     } finally {
       clearTimeout(timeout);
     }
@@ -1580,25 +1737,25 @@ function toMemoryNodes(turn, projectId, opts = {}) {
   const assistantRedacted = redact(turn.assistantText);
   const chunks = chunkAssistantText(assistantRedacted.text, maxChunk);
   if (chunks.length === 0) return [];
-  return chunks.map((chunk, index) => {
-    const body = [`Q: ${userRedacted.text}`, "", `A: ${chunk.text}`].join("\n");
+  return chunks.map((chunk2, index) => {
+    const body = [`Q: ${userRedacted.text}`, "", `A: ${chunk2.text}`].join("\n");
     return {
       id: makeNodeId(projectId, "conversation_turn", `${turn.naturalKey}:${index}`),
       kind: "conversation_turn",
       projectId,
       ts: turn.ts,
       source: `conversation:${turn.source}`,
-      title: chunkTitle(userFirstLine, chunk.heading, index, chunks.length),
+      title: chunkTitle(userFirstLine, chunk2.heading, index, chunks.length),
       body: truncate(body, maxBody),
       files: extractMentionedFiles(`${userRedacted.text}
-${chunk.text}`),
-      signal: scoreConversationTurn(userRedacted.text, chunk.text),
+${chunk2.text}`),
+      signal: scoreConversationTurn(userRedacted.text, chunk2.text),
       meta: {
         cwd: turn.cwd,
         source: turn.source,
         chunkIndex: index,
         chunkCount: chunks.length,
-        heading: chunk.heading,
+        heading: chunk2.heading,
         // Redaction runs once over the whole reply before chunking (so a
         // secret can never straddle a chunk boundary and slip through) --
         // this is the turn's total, repeated on every chunk it produced,
@@ -1754,8 +1911,8 @@ async function* readCommitDiffs(cwd, opts = {}) {
   const args = buildDiffLogArgs(opts);
   let buffer = "";
   try {
-    for await (const chunk of gitStream(cwd, args)) {
-      buffer += chunk;
+    for await (const chunk2 of gitStream(cwd, args)) {
+      buffer += chunk2;
       const { records, rest } = splitRecords(buffer);
       buffer = rest;
       for (const record of records) {
@@ -1911,8 +2068,8 @@ async function* readCommits(cwd, opts = {}) {
   const args = buildLogArgs(opts);
   let buffer = "";
   try {
-    for await (const chunk of gitStream(cwd, args)) {
-      buffer += chunk;
+    for await (const chunk2 of gitStream(cwd, args)) {
+      buffer += chunk2;
       const { records, rest } = splitRecords(buffer);
       buffer = rest;
       for (const record of records) {
@@ -2147,8 +2304,8 @@ function toMemoryNodes3(file, projectId, opts = {}) {
   const chunks = chunkAssistantText(file.content, maxChunk);
   if (chunks.length === 0) return [];
   const seenSlugs = /* @__PURE__ */ new Map();
-  return chunks.map((chunk, index) => {
-    const baseSlug = slugify(chunk.heading, index);
+  return chunks.map((chunk2, index) => {
+    const baseSlug = slugify(chunk2.heading, index);
     const occurrence = seenSlugs.get(baseSlug) ?? 0;
     seenSlugs.set(baseSlug, occurrence + 1);
     const naturalKey = occurrence === 0 ? `${file.path}#${baseSlug}` : `${file.path}#${baseSlug}:${occurrence}`;
@@ -2158,13 +2315,13 @@ function toMemoryNodes3(file, projectId, opts = {}) {
       projectId,
       ts: file.ts,
       source: "docs",
-      title: sectionTitle(file.path, chunk.heading, index, chunks.length),
-      body: truncate(chunk.text, maxBody),
+      title: sectionTitle(file.path, chunk2.heading, index, chunks.length),
+      body: truncate(chunk2.text, maxBody),
       files: [{ path: file.path, insertions: null, deletions: null, binary: false }],
-      signal: scoreDocSection(file.path, chunk.heading, chunk.text),
+      signal: scoreDocSection(file.path, chunk2.heading, chunk2.text),
       meta: {
         path: file.path,
-        heading: chunk.heading,
+        heading: chunk2.heading,
         chunkIndex: index,
         chunkCount: chunks.length
       }
@@ -2175,9 +2332,217 @@ function collectDocFiles(files, projectId, opts = {}) {
   return files.flatMap((file) => toMemoryNodes3(file, projectId, opts));
 }
 
-// src/collectors/shell-history.ts
-var DEFAULT_MAX_BODY_CHARS3 = 1e3;
+// src/slm/summarize.ts
+var MAX_USER_CHARS = 400;
+var MAX_REPLY_CHARS = 700;
+var DEFAULT_MAX_PROMPT_CHARS = 12e3;
+function groupTurnsIntoSessions(turns) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const turn of turns) {
+    const existing = groups.get(turn.sessionKey);
+    if (existing) {
+      existing.turns.push(turn);
+      if (turn.ts < existing.startedAt) existing.startedAt = turn.ts;
+      if (turn.ts > existing.endedAt) existing.endedAt = turn.ts;
+      existing.cwd ??= turn.cwd;
+      continue;
+    }
+    groups.set(turn.sessionKey, {
+      sessionKey: turn.sessionKey,
+      source: turn.source,
+      cwd: turn.cwd,
+      turns: [turn],
+      startedAt: turn.ts,
+      endedAt: turn.ts
+    });
+  }
+  for (const group of groups.values()) {
+    group.turns.sort((a, b) => a.ts.localeCompare(b.ts));
+  }
+  return [...groups.values()].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+function selectSettledSessions(sessions, settleMinutes, now = /* @__PURE__ */ new Date()) {
+  const cutoff = now.getTime() - settleMinutes * 6e4;
+  return sessions.filter((s) => {
+    const ended = Date.parse(s.endedAt);
+    return Number.isNaN(ended) || ended <= cutoff;
+  });
+}
+var SESSION_INSTRUCTIONS = `You are summarizing one working session between a developer and an AI coding assistant, so that a future assistant can recall what happened without re-reading the transcript.
+
+Your first line MUST begin with "TITLE: " and nothing else. Start your reply with those six characters.
+
+Write your answer in exactly this shape:
+TITLE: <under 15 words, naming the specific work, e.g. "Raised the Node floor to 22 after a CI failure">
+- <a decision that was made, and why>
+- <a problem that was diagnosed, and its cause>
+- <what was left unfinished or explicitly deferred>
+
+Rules:
+- Answer in English, whatever language the transcript is in. This summary is stored in a keyword index that cannot segment languages without spaces between words.
+- The title must name this session specifically. "Summary of the session" or "Project update" are wrong.
+- Prefer reasons over narration. "Chose X over Y because Z" is worth more than "worked on X".
+- Only state what the transcript supports. Do not guess or invent.
+- Between 3 and 6 bullets. No preamble, no closing remarks, no markdown bold.`;
+function buildSessionPrompt(session, maxPromptChars = DEFAULT_MAX_PROMPT_CHARS) {
+  const rendered = session.turns.map((turn) => {
+    const user = redact(turn.userText).text;
+    const reply = redact(turn.assistantText).text;
+    return {
+      ts: turn.ts,
+      text: [`[${turn.ts}] developer: ${truncate(user, MAX_USER_CHARS)}`, `assistant: ${truncate(reply, MAX_REPLY_CHARS)}`].join(
+        "\n"
+      ),
+      signal: scoreConversationTurn(user, reply)
+    };
+  });
+  const budget = maxPromptChars - SESSION_INSTRUCTIONS.length;
+  const kept = [];
+  let used = 0;
+  for (const turn of [...rendered].sort((a, b) => b.signal - a.signal)) {
+    if (used + turn.text.length > budget) continue;
+    kept.push(turn);
+    used += turn.text.length;
+  }
+  kept.sort((a, b) => a.ts.localeCompare(b.ts));
+  const body = kept.map((t) => t.text).join("\n\n");
+  const prompt = `${SESSION_INSTRUCTIONS}
+
+---
+
+${body}
+
+---
+
+Summary:`;
+  return { prompt, hash: sha256Hex(prompt), includedTurns: kept.length };
+}
+function sessionFallbackTitle(session) {
+  const opening = session.turns[0];
+  if (!opening) return "Working session";
+  const line = redact(opening.userText).text.split(/\r?\n/)[0]?.trim();
+  return line && line.length > 0 ? line : "Working session";
+}
 var MAX_TITLE_CHARS5 = 200;
+var GENERIC_TITLE = /^(a |the )?(session |conversation |project |work )?(summary|update|overview|recap|status)\b/i;
+function cleanTitle(line) {
+  return line.replace(/^[-*#>\s]+/, "").replace(/\*+/g, "").replace(/\s*:\s*$/, "").trim();
+}
+function parseSummary(raw, fallbackTitle) {
+  const text = redact(raw).text.trim();
+  if (text.length === 0) return null;
+  const lines = text.split(/\r?\n/);
+  const firstIndex = lines.findIndex((line) => line.trim().length > 0);
+  if (firstIndex === -1) return null;
+  const first = lines[firstIndex].trim();
+  const labelled = /^TITLE:\s*(.+)$/i.exec(first);
+  const fallback = truncate(cleanTitle(fallbackTitle) || "Working session", MAX_TITLE_CHARS5);
+  if (!labelled) return { title: fallback, body: text };
+  const candidate = cleanTitle(labelled[1]);
+  const rest = lines.slice(firstIndex + 1).join("\n").trim();
+  return {
+    title: candidate.length > 0 && !GENERIC_TITLE.test(candidate) ? truncate(candidate, MAX_TITLE_CHARS5) : fallback,
+    // A model that emitted only a title still gets a usable node: the title
+    // doubles as the body rather than storing an empty one.
+    body: rest.length > 0 ? rest : candidate
+  };
+}
+
+// src/collectors/sessions.ts
+var SESSION_SOURCE_PREFIX = "session";
+var DEFAULT_SETTLE_MINUTES = 30;
+var DEFAULT_MAX_BODY_CHARS3 = 2500;
+var DEFAULT_MAX_SESSIONS = 10;
+function scoreSession(turnCount) {
+  const score = 0.6 + Math.min(0.25, turnCount / 100);
+  return Number(score.toFixed(3));
+}
+function toNode(session, projectId, summary, meta, maxBodyChars) {
+  const header = `Session of ${session.startedAt.slice(0, 10)} \u2014 ${session.turns.length} exchange(s)`;
+  const body = `${header}
+
+${summary.body}`;
+  return {
+    id: makeNodeId(projectId, "session_summary", session.sessionKey),
+    kind: "session_summary",
+    projectId,
+    // The session's end, not its start: a summary describes a finished piece
+    // of work, and recency ranking should treat it as being as fresh as the
+    // last thing that happened in it.
+    ts: session.endedAt,
+    source: `${SESSION_SOURCE_PREFIX}:${session.source}`,
+    title: truncate(summary.title, 200),
+    body: truncate(body, maxBodyChars),
+    // Drawn from the whole session rather than only the summary: the model
+    // mentions few paths, but `node_files` is what lets "why is this file
+    // like this" reach the session that explains it.
+    files: extractMentionedFiles(session.turns.map((t) => `${t.userText}
+${t.assistantText}`).join("\n")),
+    signal: scoreSession(session.turns.length),
+    meta: {
+      sessionKey: session.sessionKey,
+      source: session.source,
+      turnCount: session.turns.length,
+      summarizedTurns: meta.includedTurns,
+      startedAt: session.startedAt,
+      endedAt: session.endedAt,
+      cwd: session.cwd,
+      model: meta.model,
+      contentHash: meta.hash
+    }
+  };
+}
+async function collectSessionSummaries(turns, projectId, provider, opts = {}) {
+  const maxBodyChars = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const maxSessions = opts.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  const all = groupTurnsIntoSessions(turns);
+  const settled = selectSettledSessions(all, opts.settleMinutes ?? DEFAULT_SETTLE_MINUTES, opts.now);
+  const nodes = [];
+  let cached = 0;
+  let failed = 0;
+  let attempted = 0;
+  const candidates = [...settled].sort((a, b) => b.endedAt.localeCompare(a.endedAt));
+  const pending = [];
+  for (const session of candidates) {
+    const prompt = buildSessionPrompt(session, opts.maxPromptChars);
+    if (opts.knownHash?.(session.sessionKey) === prompt.hash) {
+      cached += 1;
+      continue;
+    }
+    pending.push({ session, prompt });
+  }
+  for (const { session, prompt } of pending.slice(0, maxSessions)) {
+    const raw = await provider.complete(prompt.prompt);
+    attempted += 1;
+    const summary = raw === null ? null : parseSummary(raw, sessionFallbackTitle(session));
+    if (!summary) {
+      failed += 1;
+      continue;
+    }
+    nodes.push(
+      toNode(
+        session,
+        projectId,
+        summary,
+        { hash: prompt.hash, model: provider.identity, includedTurns: prompt.includedTurns },
+        maxBodyChars
+      )
+    );
+    opts.onProgress?.(nodes.length, Math.min(pending.length, maxSessions));
+  }
+  return {
+    nodes,
+    cached,
+    unsettled: all.length - settled.length,
+    deferred: Math.max(0, pending.length - maxSessions),
+    failed,
+    providerUnavailable: attempted > 0 && nodes.length === 0
+  };
+}
+
+// src/collectors/shell-history.ts
+var DEFAULT_MAX_BODY_CHARS4 = 1e3;
+var MAX_TITLE_CHARS6 = 200;
 var NOISE = /^(cd|ls|dir|pwd|clear|cls|exit|history|whoami|date|type|cat|more|less|ll|la)\b/i;
 var BUILD_TEST = /^(npm|pnpm|yarn)\s+(run\s+)?(test|build|lint|typecheck|tsc)\b|^(pytest|go\s+test|cargo\s+(test|build)|mvn\s+test|gradle\s+test|dotnet\s+(test|build))\b/i;
 var INSTALL = /^(npm|pnpm|yarn)\s+(install|add|remove|uninstall|ci)\b|^pip\s+install\b|^(cargo\s+add|go\s+get|composer\s+require)\b/i;
@@ -2210,7 +2575,7 @@ function renderBody(entry, maxChars) {
   return truncate(parts.join("\n"), maxChars);
 }
 function toMemoryNode2(entry, projectId, opts = {}) {
-  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS4;
   const titleLine = entry.command.split(/\r?\n/)[0] ?? entry.command;
   return {
     id: makeNodeId(projectId, "shell_command", entry.naturalKey),
@@ -2218,7 +2583,7 @@ function toMemoryNode2(entry, projectId, opts = {}) {
     projectId,
     ts: entry.ts,
     source: `shell:${entry.shell}`,
-    title: truncate(titleLine, MAX_TITLE_CHARS5),
+    title: truncate(titleLine, MAX_TITLE_CHARS6),
     body: renderBody(entry, maxBody),
     files: [],
     signal: scoreShellCommand(entry),
@@ -2238,6 +2603,7 @@ function collectShellHistory(entries, projectId, opts = {}) {
 
 // src/conversation/claude-code-reader.ts
 import { readFile as readFile4 } from "fs/promises";
+import { basename as basename2 } from "path";
 
 // src/conversation/paths.ts
 import { existsSync as existsSync3 } from "fs";
@@ -2284,6 +2650,7 @@ function extractAssistantText(line) {
 }
 function parseClaudeCodeTranscript(raw, opts = {}) {
   const source = opts.source ?? "claude-code";
+  const sessionKey = `${source}:${opts.sessionId ?? "unknown"}`;
   const turns = [];
   let current = null;
   const flush = () => {
@@ -2295,7 +2662,8 @@ function parseClaudeCodeTranscript(raw, opts = {}) {
       assistantText,
       ts: current.ts,
       cwd: current.cwd,
-      source
+      source,
+      sessionKey
     });
     current = null;
   };
@@ -2328,7 +2696,7 @@ async function collectClaudeCodeTranscripts(repoRoot) {
   const turns = [];
   for (const file of files) {
     const raw = await readFile4(file, "utf8");
-    turns.push(...parseClaudeCodeTranscript(raw));
+    turns.push(...parseClaudeCodeTranscript(raw, { sessionId: basename2(file, ".jsonl") }));
   }
   return turns;
 }
@@ -2554,21 +2922,76 @@ async function collectAvailableShellHistory(opts = {}) {
 }
 
 // src/vector/sync.ts
+var EMBEDDING_IDENTITY_KEY = "embedding.identity";
+var DEFAULT_BATCH_SIZE = 32;
+var DEFAULT_PAGE_SIZE = 500;
+var DEFAULT_FAILURE_TOLERANCE = 3;
+function reconcileProviderIdentity(store, provider) {
+  if (store.getMeta(EMBEDDING_IDENTITY_KEY) === provider.identity) return 0;
+  const invalidated = store.dropAllEmbeddings();
+  store.setMeta(EMBEDDING_IDENTITY_KEY, provider.identity);
+  return invalidated;
+}
+async function embedTexts(provider, texts) {
+  if (provider.embedBatch) return provider.embedBatch(texts);
+  const out = [];
+  for (const text of texts) out.push(await provider.embed(text));
+  return out;
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
 async function embedPendingNodes(store, provider, projectId, opts = {}) {
-  const pending = store.findNodesNeedingEmbedding(projectId, opts.batchLimit ?? 200);
+  const batchSize = opts.batchSize ?? DEFAULT_BATCH_SIZE;
+  const pageSize = opts.pageSize ?? DEFAULT_PAGE_SIZE;
+  const failureTolerance = opts.failureTolerance ?? DEFAULT_FAILURE_TOLERANCE;
+  const maxNodes = opts.maxNodes ?? Number.POSITIVE_INFINITY;
+  const invalidated = reconcileProviderIdentity(store, provider);
+  if (invalidated > 0) opts.onInvalidated?.(invalidated);
+  const total = Math.min(store.countNodesNeedingEmbedding(projectId), maxNodes);
   let embedded = 0;
   let skipped = 0;
-  for (const node of pending) {
-    const vector = await provider.embed(`${node.title}
-${node.body}`);
-    if (vector && vector.length === provider.dimension) {
-      store.upsertEmbedding(node.rowid, vector);
-      embedded += 1;
-    } else {
-      skipped += 1;
+  let attempted = 0;
+  let consecutiveFailedRequests = 0;
+  let cursor = 0;
+  outer: while (attempted < maxNodes) {
+    const page = store.findNodesNeedingEmbedding(projectId, Math.min(pageSize, maxNodes - attempted), cursor);
+    if (page.length === 0) break;
+    cursor = page[page.length - 1].rowid;
+    for (const group of chunk(page, batchSize)) {
+      const vectors = await embedTexts(
+        provider,
+        group.map((node) => `${node.title}
+${node.body}`)
+      );
+      let embeddedHere = 0;
+      for (const [index, node] of group.entries()) {
+        const vector = vectors[index];
+        if (vector && vector.length === provider.dimension) {
+          store.upsertEmbedding(node.rowid, vector);
+          embedded += 1;
+          embeddedHere += 1;
+        } else {
+          skipped += 1;
+        }
+      }
+      attempted += group.length;
+      consecutiveFailedRequests = embeddedHere === 0 ? consecutiveFailedRequests + 1 : 0;
+      opts.onProgress?.(attempted, total);
+      if (consecutiveFailedRequests >= failureTolerance) break outer;
     }
   }
-  return { embedded, skipped, providerUnavailable: pending.length > 0 && embedded === 0 };
+  return {
+    embedded,
+    skipped,
+    // Unchanged meaning: nothing came back at all. Reached far sooner now --
+    // `failureTolerance` requests instead of the whole first page.
+    providerUnavailable: attempted > 0 && embedded === 0,
+    invalidated,
+    remaining: store.countNodesNeedingEmbedding(projectId)
+  };
 }
 
 // src/cli/context.ts
@@ -2581,6 +3004,8 @@ async function loadContext(cwd) {
 
 // src/cli/commands/sync.ts
 var BATCH_SIZE = 500;
+var PROGRESS_THRESHOLD = 200;
+var PROGRESS_EVERY = 100;
 var GIT_SOURCE = "git";
 function addStats(into, from) {
   into.inserted += from.inserted;
@@ -2704,13 +3129,12 @@ async function syncShell(store, projectId, opts, repoRoot, config, log) {
   return { totals, seen };
 }
 var CONVERSATION_SOURCE = "conversation:claude-code";
-async function syncConversation(store, projectId, repoRoot, config, log, forceEnabled) {
+function syncConversation(store, projectId, turns, config, log, forceEnabled) {
   const totals = { inserted: 0, updated: 0, unchanged: 0 };
   const enabled = forceEnabled ?? config.sources.conversation.enabled;
   if (!enabled) {
     return { totals, seen: 0 };
   }
-  const turns = await collectClaudeCodeTranscripts(repoRoot);
   if (turns.length === 0) {
     log(`${pc4.dim("conversation")} no transcripts found`);
     return { totals, seen: 0 };
@@ -2721,6 +3145,42 @@ async function syncConversation(store, projectId, repoRoot, config, log, forceEn
   log(`  ${pc4.dim(`${CONVERSATION_SOURCE}: ${nodes.length} of ${turns.length} exchange(s) kept`)}`);
   return { totals, seen: nodes.length };
 }
+var SESSION_SOURCE = "session:claude-code";
+async function syncSessions(store, projectId, turns, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  const settings = config.sources.session;
+  if (!settings.enabled) return { totals, seen: 0 };
+  if (turns.length === 0) {
+    log(`${pc4.dim("session")} no transcripts found`);
+    return { totals, seen: 0 };
+  }
+  const result = await collectSessionSummaries(turns, projectId, new OllamaChatProvider({ model: settings.model }), {
+    settleMinutes: settings.settleMinutes,
+    maxSessions: settings.maxSessions,
+    maxPromptChars: settings.maxPromptChars,
+    maxBodyChars: config.limits.maxBodyChars,
+    knownHash: (sessionKey) => {
+      const meta = store.getNodeMeta(makeNodeId(projectId, "session_summary", sessionKey));
+      return typeof meta?.contentHash === "string" ? meta.contentHash : null;
+    },
+    onProgress: (done, total) => log(`  ${pc4.dim(`session: summarizing ${done}/${total}`)}`)
+  });
+  if (result.nodes.length > 0) addStats(totals, store.upsertNodes(result.nodes));
+  if (result.providerUnavailable) {
+    log(
+      `${pc4.dim("session")} summarization model unavailable (is Ollama running with \`${settings.model}\` pulled?) -- skipped`
+    );
+  } else {
+    const parts = [`${result.nodes.length} summarized`];
+    if (result.cached > 0) parts.push(`${result.cached} unchanged`);
+    if (result.deferred > 0) parts.push(`${result.deferred} queued for the next sync`);
+    if (result.unsettled > 0) parts.push(`${result.unsettled} still active`);
+    if (result.failed > 0) parts.push(`${result.failed} failed`);
+    log(`  ${pc4.dim(`${SESSION_SOURCE}: ${parts.join(", ")}`)}`);
+  }
+  store.setSyncCursor(projectId, SESSION_SOURCE, `scanned:${result.nodes.length}`);
+  return { totals, seen: result.nodes.length };
+}
 var DOCS_SOURCE = "docs";
 async function syncDocs(store, projectId, repoRoot, config, log) {
   const totals = { inserted: 0, updated: 0, unchanged: 0 };
@@ -2753,7 +3213,7 @@ async function runSync(opts) {
     if (!opts.quiet) process.stderr.write(`${line}
 `);
   };
-  const out = opts.out ?? ((chunk) => void process.stdout.write(chunk));
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
   const store = MemoryStore.open(ws.dbPath);
   const started = Date.now();
   try {
@@ -2766,13 +3226,27 @@ async function runSync(opts) {
     const git2 = await syncGit(store, projectId, opts, repo, config, log);
     const diffs = await syncDiffs(store, projectId, opts, repo, config, log);
     const shell = await syncShell(store, projectId, opts, repo.root, config, log);
-    const conversation = await syncConversation(store, projectId, repo.root, config, log, opts.conversationOverride);
+    const conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
+    const turns = conversationEnabled || config.sources.session.enabled ? await collectClaudeCodeTranscripts(repo.root) : [];
+    const conversation = syncConversation(store, projectId, turns, config, log, opts.conversationOverride);
+    const sessions = await syncSessions(store, projectId, turns, config, log);
     const docs = await syncDocs(store, projectId, repo.root, config, log);
     let embedLine = "";
     if (!opts.noEmbed) {
-      const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId);
+      let lastLogged = 0;
+      const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId, {
+        maxNodes: opts.embedLimit,
+        onInvalidated: (count) => log(`${pc4.yellow("vector")} embedding model changed -- dropped ${count} vector(s), re-embedding from scratch`),
+        onProgress: (attempted, total) => {
+          if (total < PROGRESS_THRESHOLD || attempted - lastLogged < PROGRESS_EVERY) return;
+          lastLogged = attempted;
+          log(`  ${pc4.dim(`vector: ${attempted}/${total} embedded`)}`);
+        }
+      });
       if (result.embedded > 0) {
-        embedLine = `  ${pc4.dim(`vector: ${result.embedded} node(s) embedded`)}${result.skipped > 0 ? pc4.dim(`, ${result.skipped} skipped`) : ""}
+        const skippedPart = result.skipped > 0 ? pc4.dim(`, ${result.skipped} skipped`) : "";
+        const remainingPart = result.remaining > 0 ? pc4.yellow(`, ${result.remaining} still pending`) : "";
+        embedLine = `  ${pc4.dim(`vector: ${result.embedded} node(s) embedded`)}${skippedPart}${remainingPart}
 `;
       } else if (result.providerUnavailable) {
         log(`${pc4.dim("vector")} embedding provider unavailable (is Ollama running with nomic-embed-text pulled?) -- BM25-only for now`);
@@ -2784,16 +3258,17 @@ async function runSync(opts) {
     addStats(totals, diffs.totals);
     addStats(totals, shell.totals);
     addStats(totals, conversation.totals);
+    addStats(totals, sessions.totals);
     addStats(totals, docs.totals);
     const stats = store.stats(projectId);
     const elapsed = ((Date.now() - started) / 1e3).toFixed(2);
-    const conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
     const conversationPart = conversationEnabled ? `, ${conversation.seen} conversation exchange(s)` : "";
+    const sessionPart = config.sources.session.enabled ? `, ${sessions.seen} session summar${sessions.seen === 1 ? "y" : "ies"}` : "";
     const docsPart = config.sources.docs.enabled ? `, ${docs.seen} doc section(s)` : "";
     const diffPart = config.sources.diff.enabled ? `, ${diffs.seen} file diff(s)` : "";
     out(
       [
-        `${pc4.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${docsPart} in ${elapsed}s`,
+        `${pc4.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${sessionPart}${docsPart} in ${elapsed}s`,
         `  ${pc4.green(`+${totals.inserted} new`)}  ${pc4.yellow(`~${totals.updated} updated`)}  ${pc4.dim(`=${totals.unchanged} unchanged`)}`,
         `  ${pc4.dim(`${stats.total} node(s) total across ${stats.distinctFiles} file path(s)`)}`,
         ""
@@ -2844,7 +3319,7 @@ async function searchMemory(input) {
       vectorMatched: vectorCount,
       tokensUsed: packed.tokensUsed,
       tokensBudget: packed.tokensBudget,
-      projectsSearched: [basename2(repo.root) || repo.root]
+      projectsSearched: [basename3(repo.root) || repo.root]
     };
   } finally {
     store.close();
@@ -2852,8 +3327,8 @@ async function searchMemory(input) {
 }
 async function syncProject(input) {
   const chunks = [];
-  const out = (chunk) => {
-    chunks.push(chunk);
+  const out = (chunk2) => {
+    chunks.push(chunk2);
   };
   await runInit({ cwd: input.projectRoot, force: false, hook: false, enableConversation: false, out });
   const opts = {
@@ -2887,7 +3362,7 @@ function createServer() {
     "search_memory",
     {
       title: "Search remembered project history",
-      description: "Search a NexusMem-tracked repository's remembered history: git commits, code diffs (the patch of each changed file), shell commands, tracked markdown docs, and (if enabled) conversation transcripts. Returns a token-budgeted, ranked context block -- not raw search results.",
+      description: "Search a NexusMem-tracked repository's remembered history: git commits, code diffs (the patch of each changed file), shell commands, tracked markdown docs, and (if enabled) conversation transcripts and per-session summaries. Returns a token-budgeted, ranked context block -- not raw search results.",
       inputSchema: {
         projectRoot: z3.string().describe("Absolute path to the repository root"),
         query: z3.string().describe("Free-text question or search terms"),
@@ -3249,17 +3724,101 @@ function formatNode4(node) {
   return [formatSignal(node.signal, DOCS_SIGNAL_BANDS), node.title].join(" ");
 }
 
-// src/cli/commands/scan-shell.ts
+// src/cli/commands/scan-session.ts
 import pc11 from "picocolors";
+async function runScanSession(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const turns = await collectClaudeCodeTranscripts(repo.root);
+  if (turns.length === 0) {
+    process.stderr.write(`${pc11.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
+`);
+    return 0;
+  }
+  const sessions = groupTurnsIntoSessions(turns);
+  const settled = selectSettledSessions(sessions, opts.settleMinutes);
+  if (!opts.json) {
+    process.stderr.write(
+      `${pc11.dim("sessions")} ${sessions.length} found, ${settled.length} settled (quiet ${opts.settleMinutes}m+)
+
+`
+    );
+  }
+  if (opts.dryRun) {
+    const previews = settled.slice(0, opts.maxSessions).map((session) => {
+      const { prompt, hash, includedTurns } = buildSessionPrompt(session);
+      return {
+        sessionKey: session.sessionKey,
+        startedAt: session.startedAt,
+        endedAt: session.endedAt,
+        turns: session.turns.length,
+        includedTurns,
+        hash,
+        promptChars: prompt.length,
+        prompt
+      };
+    });
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(previews, null, 2)}
+`);
+      return 0;
+    }
+    for (const preview of previews) {
+      process.stdout.write(
+        `${pc11.bold(preview.sessionKey)}  ${preview.startedAt.slice(0, 16).replace("T", " ")}  ${preview.includedTurns}/${preview.turns} turn(s), ${preview.promptChars} chars
+${preview.prompt}
+
+`
+      );
+    }
+    return 0;
+  }
+  const result = await collectSessionSummaries(turns, projectId, new OllamaChatProvider({ model: opts.model }), {
+    settleMinutes: opts.settleMinutes,
+    maxSessions: opts.maxSessions,
+    onProgress: (done, total) => {
+      if (!opts.json) process.stderr.write(`  ${pc11.dim(`summarizing ${done}/${total}`)}
+`);
+    }
+  });
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(result.nodes, null, 2)}
+`);
+    return 0;
+  }
+  for (const node of result.nodes) {
+    process.stdout.write(`${pc11.bold(node.title)}
+${pc11.dim(node.ts.slice(0, 16).replace("T", " "))}
+${node.body}
+
+`);
+  }
+  if (result.providerUnavailable) {
+    process.stderr.write(
+      `${pc11.yellow("model unavailable")} -- is Ollama running with \`${opts.model}\` pulled? (\`ollama pull ${opts.model}\`)
+`
+    );
+    return 0;
+  }
+  process.stderr.write(
+    `${pc11.bold(String(result.nodes.length))} summarized` + (result.failed > 0 ? `, ${pc11.yellow(`${result.failed} failed`)}` : "") + ` ${pc11.dim(`(model ${opts.model})`)}
+`
+  );
+  return 0;
+}
+var SCAN_SESSION_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
+
+// src/cli/commands/scan-shell.ts
+import pc12 from "picocolors";
 async function runScanShell(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
   const results = await collectAvailableShellHistory({ tailLines: opts.tailLines, repoRoot: repo.root });
   if (!opts.json) {
     process.stderr.write(
-      results.length ? `${pc11.dim("sources found")} ${results.map((r) => r.name).join(", ")}
+      results.length ? `${pc12.dim("sources found")} ${results.map((r) => r.name).join(", ")}
 
-` : `${pc11.yellow("no shell history source found on this machine")}
+` : `${pc12.yellow("no shell history source found on this machine")}
 `
     );
   }
@@ -3268,7 +3827,7 @@ async function runScanShell(opts) {
     const nodes = collectShellHistory(result.entries, projectId).filter((n) => n.signal >= opts.minSignal);
     allNodes.push(...nodes);
     if (!opts.json) {
-      process.stdout.write(`${pc11.bold(`shell:${result.name}`)} ${pc11.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
+      process.stdout.write(`${pc12.bold(`shell:${result.name}`)} ${pc12.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
 `);
       for (const node of nodes) process.stdout.write(`${formatNode5(node)}
 `);
@@ -3281,20 +3840,20 @@ async function runScanShell(opts) {
     return 0;
   }
   const approxTotal = allNodes.reduce((n, x) => n + approxTokens(x.body), 0);
-  process.stderr.write(`${pc11.bold(String(allNodes.length))} node(s) total  ${pc11.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+  process.stderr.write(`${pc12.bold(String(allNodes.length))} node(s) total  ${pc12.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
 `);
   return 0;
 }
 function formatNode5(node) {
-  const approx = node.meta.tsApprox ? pc11.dim("~") : " ";
+  const approx = node.meta.tsApprox ? pc12.dim("~") : " ";
   const exit = node.meta.exitCode;
-  const exitLabel = typeof exit === "number" && exit !== 0 ? pc11.red(`exit ${exit}`) : "";
+  const exitLabel = typeof exit === "number" && exit !== 0 ? pc12.red(`exit ${exit}`) : "";
   return [formatSignal(node.signal, SHELL_SIGNAL_BANDS), approx + node.ts.slice(0, 16).replace("T", " "), node.title, exitLabel].filter(Boolean).join(" ");
 }
 
 // src/cli/commands/status.ts
 import { statSync } from "fs";
-import pc12 from "picocolors";
+import pc13 from "picocolors";
 function humanBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -3319,23 +3878,23 @@ async function runStatus(opts) {
     const kinds = Object.entries(stats.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
     process.stdout.write(
       [
-        `${pc12.dim("repo    ")} ${repo.root}`,
-        `${pc12.dim("branch  ")} ${repo.branch ?? pc12.yellow("(detached)")}`,
-        `${pc12.dim("project ")} ${pc12.cyan(projectId)}`,
-        `${pc12.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc12.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
-        `${pc12.dim("database")} ${ws.dbPath} ${pc12.dim(`(${humanBytes(dbBytes)})`)}`,
+        `${pc13.dim("repo    ")} ${repo.root}`,
+        `${pc13.dim("branch  ")} ${repo.branch ?? pc13.yellow("(detached)")}`,
+        `${pc13.dim("project ")} ${pc13.cyan(projectId)}`,
+        `${pc13.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc13.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc13.dim("database")} ${ws.dbPath} ${pc13.dim(`(${humanBytes(dbBytes)})`)}`,
         "",
-        `${pc12.bold(String(stats.total))} node(s)${stats.total ? ` ${pc12.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc13.bold(String(stats.total))} node(s)${stats.total ? ` ${pc13.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats.total ? `    ${pc12.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
+        stats.total ? `    ${pc13.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
         "",
-        sources.length ? pc12.dim("sources") : pc12.yellow("no sources synced yet"),
+        sources.length ? pc13.dim("sources") : pc13.yellow("no sources synced yet"),
         ...sources.map((s) => {
           const when = s.lastRunAt ? new Date(s.lastRunAt).toISOString().slice(0, 16).replace("T", " ") : "never";
           const cursorLabel = s.source === "git" ? s.cursor?.slice(0, 7) ?? "-" : s.cursor ?? "-";
-          return `    ${s.source.padEnd(14)} ${pc12.dim(`last run ${when}`)}  ${pc12.dim(`cursor ${cursorLabel}`)}`;
+          return `    ${s.source.padEnd(14)} ${pc13.dim(`last run ${when}`)}  ${pc13.dim(`cursor ${cursorLabel}`)}`;
         }),
-        gitCursor && gitCursor !== repo.head ? `${pc12.yellow("git behind HEAD")} \u2014 run ${pc12.bold("nexusmem sync")}` : "",
+        gitCursor && gitCursor !== repo.head ? `${pc13.yellow("git behind HEAD")} \u2014 run ${pc13.bold("nexusmem sync")}` : "",
         ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
@@ -3359,7 +3918,7 @@ function guard(run) {
       process.exitCode = await run();
     } catch (err) {
       if (isExpected(err)) {
-        process.stderr.write(`${pc13.red("error")} ${err.message}
+        process.stderr.write(`${pc14.red("error")} ${err.message}
 `);
         process.exitCode = 1;
         return;
@@ -3375,7 +3934,11 @@ program.command("init").description("Create the .nexusmem workspace and database
     () => runInit({ cwd: options.cwd, force: options.force, hook: options.hook, enableConversation: options.enableConversation })
   )()
 );
-program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option("-q, --quiet", "only print the final summary", false).action(
+program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option(
+  "--embed-limit <count>",
+  "stop embedding after this many nodes (default: embed everything pending)",
+  (v) => Number.parseInt(v, 10)
+).option("-q, --quiet", "only print the final summary", false).action(
   (options) => guard(
     () => runSync({
       cwd: options.cwd,
@@ -3385,6 +3948,7 @@ program.command("sync").description("Ingest new history into the local database"
       shellTailLines: options.shellLines,
       conversationOverride: options.conversation ? true : void 0,
       noEmbed: !options.embed,
+      embedLimit: options.embedLimit,
       quiet: options.quiet
     })
   )()
@@ -3443,11 +4007,23 @@ program.command("scan-shell").description("Preview the MemoryNodes shell history
 program.command("scan-conversation").description("Preview the MemoryNodes the conversation transcript would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
   (options) => guard(() => runScanConversation({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))()
 );
+program.command("scan-session").description("Preview the session summaries a local model would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--model <name>", "Ollama model to summarize with", SCAN_SESSION_DEFAULT_MODEL).option("--settle-minutes <count>", "minutes of quiet before a session counts as finished", (v) => Number.parseInt(v, 10), 30).option("-n, --max-sessions <count>", "how many sessions to summarize", (v) => Number.parseInt(v, 10), 3).option("--dry-run", "print the prompts instead of calling the model", false).option("--json", "emit as JSON on stdout", false).action(
+  (options) => guard(
+    () => runScanSession({
+      cwd: options.cwd,
+      model: options.model,
+      settleMinutes: options.settleMinutes,
+      maxSessions: options.maxSessions,
+      dryRun: options.dryRun,
+      json: options.json
+    })
+  )()
+);
 program.command("scan-docs").description("Preview the MemoryNodes tracked .md files would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action((options) => guard(() => runScanDocs({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))());
 program.command("mcp").description("Start the MCP server (stdio transport) for Claude Desktop, Cursor, Windsurf, etc.").action(() => guard(() => runMcpServer().then(() => 0))());
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`${pc13.red("error")} ${message}
+  process.stderr.write(`${pc14.red("error")} ${message}
 `);
   process.exitCode = 1;
 });