thincoder 0.8.11 → 0.8.13

package/src/config.mjs

@@ -18,7 +18,7 @@ export const PROVIDER_PRESETS = {
   kimi:     { baseURL: "https://api.moonshot.cn/v1", model: "kimi-k3", thinking: null, reasoningEffort: "max", maxTokens: 131072, desc: "Kimi / Moonshot" },
   glm:      { baseURL: "https://open.bigmodel.cn/api/paas/v4", model: "glm-5.2", thinking: { type: "enabled" }, reasoningEffort: "max", maxTokens: 131072, desc: "Zhipu GLM" },
   qwen:     { baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1", model: "qwen3.7-max", maxTokens: 131072, desc: "Qwen / Alibaba" },
-  minimax:  { baseURL: "https://api.minimax.chat/v1", chatPath: "/text/chatcompletion_v2", model: "MiniMax-M3", maxTokens: 131072, desc: "MiniMax" },
+  minimax:  { baseURL: "https://api.minimaxi.com/v1", model: "MiniMax-M3", thinking: { type: "adaptive" }, maxTokens: 131072, desc: "MiniMax" },
 }
 
 // Default provider matches deepseek preset (strip the desc display field)
@@ -30,8 +30,12 @@ const DEFAULTS = {
   agent: {
     maxTurns: 100,
     subagentTurns: 100,
+    goalTurns: 200,
     compactThreshold: 100000,
     verifyGuard: false,  // push model back to verify when files were mutated but verify not run (opt-in)
+    streamRules: [],      // time-traveling stream rules: [{ pattern: "regex", message: "reminder", action: "abort"|"warn", repeat: "always"|"once" }]
+    advisor: { enabled: false },  // automated code review after each tool-execution turn; optionally: { enabled: true, provider: "deepseek", model: "deepseek-chat" }
+    autoThink: false,     // auto-classify task difficulty and set reasoning effort per-turn
   },
   memory: {
     dbPath: join(configDir, "memory.db"),
@@ -59,6 +63,7 @@ const DEFAULTS = {
  * multimodal:        whether multimodal (image/vision input supported)
  * cacheMode:         context caching mode: "auto"=automatic / "prompt"=needs explicit / "none"=unsupported
  * thinkApi:          thinking API type: "type"=thinking.type field / "effort"=reasoning_effort field
+ * thinkOnValue:      when thinkApi is "type", the value used to enable thinking (default "enabled"; MiniMax uses "adaptive")
  * reasoningEcho:     reasoning_content cross-turn echo strategy: "required"=must echo (error if missing) / "optional"=echo optional (default: don't echo)
  * reasoningEffortEnum: valid reasoning_effort enum values (if undeclared, no validation — passed through as-is)
  * tempRange:         valid temperature range [min, max] (if undeclared, no clamping)
@@ -66,11 +71,11 @@ const DEFAULTS = {
 const MODEL_SPECS = [
   // DeepSeek V4 series
   ["deepseek-v4-pro",   { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "prompt", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["high", "max"], tempRange: [0, 2] }],
-  ["deepseek-v4-flash", { context: 256_000,   maxOutput: 384_000, thinking: false, prefixMode: true,  cacheMode: "prompt", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["high", "max"], tempRange: [0, 2] }],
+  ["deepseek-v4-flash", { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "prompt", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["high", "max"], tempRange: [0, 2] }],
   ["deepseek-reasoner", { context: 256_000,   maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "prompt", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["high", "max"], tempRange: [0, 2] }],
   ["deepseek-chat",     { context: 256_000,   maxOutput: 384_000, thinking: false, prefixMode: true,  cacheMode: "prompt", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["high", "max"], tempRange: [0, 2] }],
   // Kimi series
-  ["kimi-k3",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  partialMode: true, multimodal: true, cacheMode: "prompt", thinkApi: "effort", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"] }],
+  ["kimi-k3",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  partialMode: true, multimodal: true, cacheMode: "auto",  thinkApi: "effort", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"] }],
   ["kimi-k2",           { context: 256_000,   maxOutput: 128_000, thinking: false, partialMode: true, multimodal: true, cacheMode: "none" }],
   ["moonshot",          { context: 128_000,   maxOutput: 32_000,  thinking: false, cacheMode: "none" }],
   // GLM series
@@ -88,18 +93,18 @@ const MODEL_SPECS = [
   ["qwen-plus",         { context: 1_000_000, maxOutput: 32_000,  thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
   ["qwen",              { context: 1_000_000, maxOutput: 128_000, thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
   // MiniMax series
-  ["MiniMax-M3",        { context: 1_000_000, maxOutput: 128_000, thinking: true,  multimodal: true, cacheMode: "auto", thinkApi: "type", tempRange: [0, 2] }],
-  ["minimax-m3",        { context: 1_000_000, maxOutput: 128_000, thinking: true,  multimodal: true, cacheMode: "auto", thinkApi: "type", tempRange: [0, 2] }],
+  ["MiniMax-M3",        { context: 1_000_000, maxOutput: 128_000, thinking: true,  multimodal: true, cacheMode: "auto", thinkApi: "type", thinkOnValue: "adaptive", tempRange: [0, 2] }],
+  ["minimax-m3",        { context: 1_000_000, maxOutput: 128_000, thinking: true,  multimodal: true, cacheMode: "auto", thinkApi: "type", thinkOnValue: "adaptive", tempRange: [0, 2] }],
   ["minimax-m1",        { context: 256_000,   maxOutput: 128_000, thinking: false, cacheMode: "auto" }],
 ]
 const DEFAULT_SPEC = { context: 128_000, maxOutput: 32_000, cacheMode: "none" }
-// Window utilization cap: 0.8 (DeepSeek internally uses full window; compaction itself costs an LLM call, premature compaction is pure waste.
-// Reserve 20% headroom for post-compaction tail growth and output tokens)
-// But for 1M-window models, 0.8 = 800K tokens — waiting until history grows that large would blow the TPM budget,
-// and the compaction request itself might 429. Add caps: no more than 8× maxOutput (128K×8≈1M → still large but reasonable),
-// no more than 300K (reasonable working ceiling for large-window models; beyond that cache hit rates drop)
-const COMPACT_RATIO = 0.8
+// Window utilization cap: 0.6 — triggers earlier (reserving 40% headroom) because
+// injected context (directory tree, git context, outline, project instructions, memory/doc
+// search results) can consume 30-50K tokens each turn; waiting until 80% leaves no room.
+// For 1M-window models: 600K is still too high → cap at 300K.
+const COMPACT_RATIO = 0.6
 const COMPACT_CAP_TOKENS = 300_000
+const COMPACT_FLOOR = 40_000
 
 /** Look up spec by model name prefix (case-insensitive), conservative default for unknown models */
 export function specForModel(model) {
@@ -110,18 +115,13 @@ export function specForModel(model) {
   return DEFAULT_SPEC
 }
 
-/** Return the context window size for a given model name */
-export function contextWindowForModel(model) {
-  return specForModel(model).context
-}
-
 /** Derive compaction threshold; explicit is the value explicitly set in config file (takes priority), otherwise auto-computed from model */
 export function resolveCompactThreshold(explicit, model) {
   if (explicit != null) return { value: explicit, auto: false }
   const spec = specForModel(model)
   const ratioBased = Math.floor(spec.context * COMPACT_RATIO)
-  // Large-window models (1M) produce too-large ratio-based values; cap them — better to compact early than let history grow until it blows the TPM budget
-  const value = Math.min(ratioBased, COMPACT_CAP_TOKENS)
+  // Cap for large-window models (1M) and floor for small-window models (<64K, should not compact too aggressively)
+  const value = Math.max(Math.min(ratioBased, COMPACT_CAP_TOKENS), COMPACT_FLOOR)
   return { value, auto: true }
 }
 

package/src/context.mjs

@@ -143,7 +143,7 @@ function applyCompression(agent, headEnd, tailStart, note) {
  * Only called at safe points in the loop (history ends with user or tool message — a complete exchange boundary).
  * Automatically re-injects task list state after compaction.
  */
-export async function compressIfNeeded(agent, threshold) {
+export async function compressIfNeeded(agent, threshold, callbacks) {
   const history = agent.history
   // Prefer the real baseline: the last response's prompt_tokens is the measured value for the full context (system+tools+history).
   // Subsequent appended messages use estimation as increment; when no measured value exists (first turn / after restore / right after compaction), fall back to pure estimation
@@ -174,6 +174,8 @@ export async function compressIfNeeded(agent, threshold) {
   // The summary is a plain-text task, no reasoning needed — passing thinking to the compaction provider wastes tokens
   const summary = await chat({ ...agent.provider, thinking: null, reasoningEffort: null }, {
     messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
+    onToken: callbacks?.onToken,
+    onReasoning: callbacks?.onReasoning,
   })
 
   applyCompression(agent, split.headEnd, split.tailStart, COMPACTION_PREFIX + summary.content)

package/src/distill.mjs

@@ -47,11 +47,26 @@ export async function extractCandidates(provider, transcript) {
   const res = await chat(provider, {
     messages: [{ role: "user", content: DISTILL_PROMPT + transcript }],
   })
-  // Non-greedy match first JSON array (greedy [\s\S]* would eat across multiple arrays including interstitial text)
-  const match = res.content.match(/\[[\s\S]*?\]/)
-  if (!match) return []
+  // Balanced-bracket extraction: find the first '[' and track depth through nested
+  // brackets (tags arrays, nested objects, etc.) until the matching ']'.
+  // Non-greedy regex (/\[[\s\S]*?\]/) stops at the FIRST ']', which is wrong when
+  // LLM output contains nested arrays like `"tags": ["a", "b"]`.
+  const start = res.content.indexOf("[")
+  if (start === -1) return []
+  let depth = 0
+  let end = -1
+  for (let i = start; i < res.content.length; i++) {
+    const ch = res.content[i]
+    if (ch === "[" && (i === start || res.content[i - 1] !== "\\")) depth++
+    else if (ch === "]" && res.content[i - 1] !== "\\") {
+      depth--
+      if (depth === 0) { end = i + 1; break }
+    }
+  }
+  if (end === -1) return []
+  const jsonText = res.content.slice(start, end)
   try {
-    const parsed = JSON.parse(match[0])
+    const parsed = JSON.parse(jsonText)
     if (!Array.isArray(parsed)) return []
     return parsed.filter((c) => c?.type && c?.title && c?.content)
   } catch {

package/src/embedding.mjs

@@ -84,7 +84,9 @@ async function requestWithRetry(embedder, input, signal) {
           Authorization: `Bearer ${embedder.apiKey}`,
         },
         body: JSON.stringify({ model: embedder.model, input }),
-        signal,
+        signal: signal
+          ? AbortSignal.any([signal, AbortSignal.timeout(60_000)])
+          : AbortSignal.timeout(60_000),
       })
     } catch (error) {
       if (error.name === "AbortError") throw error

package/src/git/checkpoint.mjs

@@ -78,7 +78,8 @@ export async function createCheckpoint(cwd) {
     const src = join(cwd, rel)
     const dst = join(dir, "untracked", rel)
     await mkdir(dirname(dst), { recursive: true })
-    await copyFile(src, dst).catch(() => {}) // Copy failed (socket/device file etc.) — skip
+    // Copy failed (socket/device file etc.) — skip, but log in case it's unexpected
+    await copyFile(src, dst).catch((e) => console.error(`[checkpoint] skipping ${rel}: ${e.message}`))
   }
 
   await writeFile(join(dir, "meta.json"), JSON.stringify({

package/src/git/gitmem.mjs

@@ -51,11 +51,17 @@ export async function pullTeam(dir) {
     return true
   } catch (error) {
     if (await hasConflict(dir)) {
-      await git(dir, ["rebase", "--abort"]).catch(() => {})
+      let abortFailed = false
+      try { await git(dir, ["rebase", "--abort"]) } catch {
+        abortFailed = true
+      }
       throw new Error(
         `Team memory sync conflict: local and remote modified the same entry.\n` +
         `Please resolve manually in ${dir} with \`git pull\`, then re-run \`thincoder sync\`.\n` +
-        `(The local repo has been restored to its pre-sync state — nothing was lost.)`,
+        (abortFailed
+          ? `(WARNING: git rebase --abort also failed — the repo may be in a conflicted state. ` +
+            `Run \`cd ${dir} && git rebase --abort\` manually to clean up.)`
+          : `(The local repo has been restored to its pre-sync state — nothing was lost.)`),
       )
     }
     throw error

package/src/markdown.mjs

@@ -85,7 +85,7 @@ function oneLine(v) {
  * Minimal YAML subset parser: only supports `key: value` and `key: [a, b, c]`.
  * Our frontmatter is self-generated, no need for full YAML.
  */
-function parseFrontmatter(text) {
+export function parseFrontmatter(text) {
   const meta = {}
   for (const line of text.split(/\r?\n/)) {
     const m = line.match(/^(\w[\w-]*)\s*:\s*(.*)$/)

package/src/mcp/transport-http.mjs

@@ -1,7 +1,7 @@
 /**
  * mcp/transport-http.mjs — MCP HTTP + SSE transport (Streamable HTTP)
  */
-import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, withTimeout } from "./helpers.mjs"
+import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, INIT_TIMEOUT_MS, withTimeout } from "./helpers.mjs"
 
 /** Create an MCP HTTP+SSE transport for Streamable HTTP servers */
 export function httpTransport(baseURL, extraHeaders = {}) {
@@ -56,10 +56,11 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     if (closed) return
     abortController?.abort()
     abortController = new AbortController()
+    const signal = AbortSignal.any([abortController.signal, AbortSignal.timeout(INIT_TIMEOUT_MS)])
     const resp = await fetch(url, {
       method: "GET",
       headers: { Accept: "text/event-stream", ...extraHeaders },
-      signal: abortController.signal,
+      signal,
     })
     if (!resp.ok) throw new Error(`SSE connect failed: HTTP ${resp.status}`)
     eventSource = parseSSE(resp)
@@ -155,7 +156,10 @@ export function httpTransport(baseURL, extraHeaders = {}) {
       headers: headers(),
       body: JSON.stringify({ jsonrpc: "2.0", method, params }),
       signal: AbortSignal.timeout(10_000),
-    }).catch(() => {})
+    }).catch((e) => {
+      // notify is fire-and-forget by design, but log network errors for debugging
+      if (e.name !== "AbortError") console.error(`[mcp] notify failed: ${e.message}`)
+    })
   }
 
   const close = () => {
@@ -166,7 +170,10 @@ export function httpTransport(baseURL, extraHeaders = {}) {
         method: "DELETE",
         headers: { "Mcp-Session-Id": sessionId, ...extraHeaders },
         signal: AbortSignal.timeout(5_000),
-      }).catch(() => {})
+      }).catch((e) => {
+        // close is best-effort cleanup; log but don't throw
+        if (e.name !== "AbortError") console.error(`[mcp] close DELETE failed: ${e.message}`)
+      })
       sessionId = null
     }
     for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message: "Connection closed" } })

package/src/memory/code-index.mjs

@@ -140,9 +140,9 @@ export function extractLeadingDoc(lines, lineNum, ext) {
   return text.length > 0 && text.length < 300 ? text : ""
 }
 
-/** Yield control to the event loop for one tick (allows keyboard input to be processed) */
+/** Yield control to the event loop for one tick (allows keyboard input to be processed). Uses setImmediate for lower latency than setTimeout(0). */
 export function yieldTick() {
-  return new Promise((r) => setTimeout(r, 0))
+  return new Promise((r) => setImmediate(r))
 }
 
 /** Index a single file: delete old chunks → chunk → insert new chunks */

package/src/memory/code-sync.mjs

@@ -1,11 +1,10 @@
 /**
  * memory/code-sync.mjs — code index sync, retrieval, incremental update
  */
-
 import { readFile, stat } from "node:fs/promises"
 import { join, relative } from "node:path"
 import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
-import { CODE_EXTS, DOC_EXTS, SKIP_DIRS } from "./schema.mjs"
+import { CODE_EXTS, DOC_EXTS, SKIP_DIRS, MAX_CODE_FILE_BYTES, MAX_DOC_FILE_BYTES } from "./schema.mjs"
 import { buildFtsQuery, ensureEmbeddings, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { detectLanguage, _upsertCodeFile, _upsertDocFile, yieldTick } from "./code-index.mjs"
 
@@ -19,20 +18,25 @@ const CODE_EMBED_BATCH = 64
  * Returns { updated, removed, skipped } or null (git unavailable).
  */
 export async function gitSync(memory, dir, { onProgress } = {}) {
-  const { execSync, execFileSync } = await import("node:child_process")
-  const opts = { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000 }
+  const { execFile: _execFile } = await import("node:child_process")
+  const gitRun = (args) => new Promise((resolve, reject) => {
+    _execFile("git", args, { cwd: dir, encoding: "utf8", timeout: 10000, windowsHide: true }, (err, stdout) => {
+      if (err) reject(err); else resolve(stdout)
+    })
+  })
+  const mergeDiff = (text) => text.trim().split("\n").filter(Boolean)
 
   let head
-  try { head = execSync("git rev-parse HEAD", opts).trim() } catch { return null }
+  try { head = (await gitRun(["rev-parse", "HEAD"])).trim() } catch { return null }
 
   const stored = memory.db.prepare(`SELECT value FROM meta WHERE key = 'last_indexed_commit'`).get()?.value
   if (!stored) return null
 
   let diffOut
   try {
-    const committed = execFileSync("git", ["diff", "--name-only", "--diff-filter=ACMRTD", stored, "HEAD"], { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000 }).trim()
-    const dirty = execSync(`git diff --name-only --diff-filter=ACMRTD`, opts).trim()
-    const lines = [...new Set([...committed.split("\n").filter(Boolean), ...dirty.split("\n").filter(Boolean)])]
+    const committed = mergeDiff(await gitRun(["diff", "--name-only", "--diff-filter=ACMRTD", stored, "HEAD"]))
+    const dirty = mergeDiff(await gitRun(["diff", "--name-only", "--diff-filter=ACMRTD"]))
+    const lines = [...new Set([...committed, ...dirty])]
     diffOut = lines
   } catch {
     return null
@@ -83,6 +87,7 @@ export async function gitSync(memory, dir, { onProgress } = {}) {
         if (errors.length < 5) errors.push(`${rel}: ${e.message}`)
       }
     }
+    await yieldTick()
     if (onProgress && i % 5 === 0) {
       onProgress({ phase: "index", current: i + 1, total: diffOut.length, updated, removed, skipped })
     }
@@ -97,44 +102,79 @@ export async function gitSync(memory, dir, { onProgress } = {}) {
   return { updated, removed, skipped, failed, errors }
 }
 
+/**
+ * List project files matching the given extensions.
+ * Only indexes git repos — if dir isn't inside a git worktree, returns [].
+ * Uses `git ls-files --cached --others --exclude-standard` to get the file list
+ * (tracked + untracked-not-ignored, respecting .gitignore).
+ * Returns an array of { abs, rel } pairs (abs = full path, rel = path relative to dir).
+ */
+export async function listProjectFiles(dir, exts) {
+  const { execFile: _execFile } = await import("node:child_process")
+  const { join: joinPath } = await import("node:path")
+
+  // Only index git repos — if this isn't one, return empty
+  let gitTop
+  try {
+    gitTop = (await new Promise((resolve, reject) => {
+      _execFile("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8", timeout: 5000, windowsHide: true },
+        (err, stdout) => { if (err) reject(err); else resolve(stdout.trim()) })
+    })).replace(/\\/g, "/")
+  } catch {
+    return [] // not a git repo → nothing to index
+  }
+
+  const files = []
+  try {
+    const raw = await new Promise((resolve, reject) => {
+      _execFile("git", ["ls-files", "--cached", "--others", "--exclude-standard"],
+        { cwd: dir, encoding: "utf8", timeout: 15000, windowsHide: true, maxBuffer: 10 * 1024 * 1024 },
+        (err, stdout) => { if (err) reject(err); else resolve(stdout) })
+    })
+    for (const line of raw.trim().split("\n")) {
+      const p = line.trim()
+      if (!p) continue
+      const ext = p.slice(p.lastIndexOf(".")).toLowerCase()
+      if (!exts.has(ext)) continue
+      const abs = joinPath(dir, p)
+      const rel = p.replace(/\\/g, "/")
+      if (rel.split("/").some((seg) => SKIP_DIRS.has(seg) || seg.startsWith("."))) continue
+      files.push({ abs, rel })
+    }
+  } catch { /* ls-files failed */ }
+
+  return files
+}
+
+
 /**
  * Sync code index: scan all source files under dir → chunk → upsert into code_chunks.
  * Incremental by mtime — only rebuilds chunks for files that have changed.
  */
 export async function codeSync(memory, dir, { onProgress } = {}) {
-  const files = []
-  const { readdir } = await import("node:fs/promises")
-  async function walk(d) {
-    let entries
-    try { entries = await readdir(d, { withFileTypes: true }) } catch { return }
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name) || e.name.startsWith(".")) continue
-        await walk(join(d, e.name))
-      } else if (e.isFile()) {
-        const ext = e.name.slice(e.name.lastIndexOf(".")).toLowerCase()
-        if (CODE_EXTS.has(ext)) files.push(join(d, e.name))
-      }
-    }
+  const entries = await listProjectFiles(dir, CODE_EXTS)
+  const files = [] // { abs, rel, mtimeMs }
+  let overSizeSkipped = 0
+  for (const { abs, rel } of entries) {
+    let st
+    try { st = await stat(abs) } catch { continue }
+    if (st.size > MAX_CODE_FILE_BYTES) { overSizeSkipped++; continue }
+    files.push({ abs, rel, mtimeMs: Math.floor(st.mtimeMs) })
   }
-  await walk(dir)
 
   const indexed = new Map(
     memory.db.prepare(`SELECT path, mtime_ms FROM code_chunks WHERE origin = ?`).all(dir).map((r) => [r.path, r.mtime_ms])
   )
   const seen = new Set()
 
-  onProgress?.({ phase: "scan", total: files.length })
+  onProgress?.({ phase: "scan", total: files.length, overSizeSkipped })
 
   let updated = 0, removed = 0, skipped = 0, failed = 0
   const errors = []
   for (let i = 0; i < files.length; i++) {
-    const abs = files[i]
-    const rel = abs.slice(dir.length + 1).replaceAll("\\", "/")
+    const { abs, rel, mtimeMs } = files[i]
     seen.add(rel)
 
-    let mtimeMs
-    try { mtimeMs = Math.floor((await stat(abs)).mtimeMs) } catch { continue }
     if (indexed.get(rel) === mtimeMs) {
       skipped++
       continue
@@ -164,18 +204,22 @@ export async function codeSync(memory, dir, { onProgress } = {}) {
     }
   }
 
-  onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed })
+  onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed, overSizeSkipped })
   markIndexedCommit(memory, dir)
-  return { updated, removed, skipped, failed, errors, total: files.length }
+  return { updated, removed, skipped, failed, errors, total: files.length, overSizeSkipped }
 }
 
 /** Record current HEAD as the index anchor (gitSync incremental diff baseline); silently skip non-git repos */
 export async function markIndexedCommit(memory, dir) {
   try {
-    const { execSync } = await import("node:child_process")
-    const head = execSync("git rev-parse HEAD", { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim()
+    const { execFile } = await import("node:child_process")
+    const head = await new Promise((resolve, reject) => {
+      execFile("git", ["rev-parse", "HEAD"], { cwd: dir, encoding: "utf8", timeout: 5000, windowsHide: true }, (err, stdout) => {
+        if (err) reject(err); else resolve(stdout)
+      })
+    })
     memory.db.prepare(`INSERT INTO meta (key, value) VALUES ('last_indexed_commit', ?)
-      ON CONFLICT (key) DO UPDATE SET value = excluded.value`).run(head)
+      ON CONFLICT (key) DO UPDATE SET value = excluded.value`).run(head.trim())
   } catch { /* not a git repo or git unavailable, skip */ }
 }
 
@@ -236,8 +280,15 @@ export async function codeSearch(memory, query, { limit = 5 } = {}) {
     .filter(Boolean)
 }
 
-/** Lazily backfill missing vectors for code_chunks */
-export async function ensureCodeEmbeddings(memory) {
+/** Lazily backfill missing vectors for code_chunks. Guarded against concurrent calls. */
+let _codeEmbedLock = null
+export function ensureCodeEmbeddings(memory) {
+  if (_codeEmbedLock) return _codeEmbedLock
+  _codeEmbedLock = _runEnsureCodeEmbeddings(memory).finally(() => { _codeEmbedLock = null })
+  return _codeEmbedLock
+}
+
+async function _runEnsureCodeEmbeddings(memory) {
   if (!memory.embedder) return
   const modelKey = memory.embedder.model
   const stored = memory.db.prepare(`SELECT value FROM meta WHERE key = 'code_embedding_model'`).get()?.value
@@ -292,6 +343,12 @@ export async function reindexFile(memory, cwd, absPath) {
   const dirs = rel.split("/").slice(0, -1)
   if (dirs.some((d) => SKIP_DIRS.has(d) || d.startsWith("."))) return
 
+  // skip oversized files (minified bundles, test fixtures, generated code)
+  const maxBytes = CODE_EXTS.has(ext) ? MAX_CODE_FILE_BYTES : DOC_EXTS.has(ext) ? MAX_DOC_FILE_BYTES : 0
+  if (maxBytes > 0) {
+    try { const st = await stat(absPath); if (st.size > maxBytes) return } catch { /* can't stat, proceed */ }
+  }
+
   let text
   try { text = await readFile(absPath, "utf8") } catch {
     if (CODE_EXTS.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(cwd, rel)

package/src/memory/core.mjs

@@ -129,8 +129,17 @@ export function fetchEntry(memory, uid) {
 /**
  * Lazy embedding: batch-compute vectors for entries that don't have them yet (slow first time, zero cost thereafter).
  * When the embedding model changes, clear all vectors and rebuild.
+ * Guarded by a module-level lock — concurrent fire-and-forget callers share the same promise,
+ * so embedding API calls are never duplicated.
  */
-export async function ensureEmbeddings(memory) {
+let _embedLock = null
+export function ensureEmbeddings(memory) {
+  if (_embedLock) return _embedLock
+  _embedLock = _runEnsureEmbeddings(memory).finally(() => { _embedLock = null })
+  return _embedLock
+}
+
+async function _runEnsureEmbeddings(memory) {
   const modelKey = memory.embedder.model
   const stored = memory.db.prepare(`SELECT value FROM meta WHERE key = 'embedding_model'`).get()?.value
   if (stored !== modelKey) {

package/src/memory/docs.mjs

@@ -2,55 +2,45 @@
  * memory/docs.mjs — doc index sync, retrieval, agent tool generation
  */
 
-import { readFile, readdir, stat } from "node:fs/promises"
+import { readFile, stat } from "node:fs/promises"
 import { join } from "node:path"
 import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
 import { commitAndPush } from "../git/gitmem.mjs"
-import { DOC_EXTS, SKIP_DIRS } from "./schema.mjs"
-import { buildFtsQuery, put, search, putMarkdown } from "./core.mjs"
+import { DOC_EXTS, SKIP_DIRS, MAX_DOC_FILE_BYTES } from "./schema.mjs"
+import { buildFtsQuery, put, search, putMarkdown, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { _upsertDocFile, yieldTick } from "./code-index.mjs"
-import { markIndexedCommit } from "./code-sync.mjs"
+import { markIndexedCommit, listProjectFiles } from "./code-sync.mjs"
 
 const DOC_EMBED_BATCH = 64
-const EMBED_TEXT_MAX_LEN = 2000
 
 /**
  * Sync doc index: scan all .md/.mdc/.txt/.rst/.adoc under dir → chunk → upsert into doc_chunks.
  * Incremental by mtime.
  */
 export async function docSync(memory, dir, { onProgress } = {}) {
-  const files = []
-  async function walk(d) {
-    let entries
-    try { entries = await readdir(d, { withFileTypes: true }) } catch { return }
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name) || e.name.startsWith(".")) continue
-        await walk(join(d, e.name))
-      } else if (e.isFile()) {
-        const ext = e.name.slice(e.name.lastIndexOf(".")).toLowerCase()
-        if (DOC_EXTS.has(ext)) files.push(join(d, e.name))
-      }
-    }
+  const entries = await listProjectFiles(dir, DOC_EXTS)
+  const files = [] // { abs, rel, mtimeMs }
+  let overSizeSkipped = 0
+  for (const { abs, rel } of entries) {
+    let st
+    try { st = await stat(abs) } catch { continue }
+    if (st.size > MAX_DOC_FILE_BYTES) { overSizeSkipped++; continue }
+    files.push({ abs, rel, mtimeMs: Math.floor(st.mtimeMs) })
   }
-  await walk(dir)
 
   const indexed = new Map(
     memory.db.prepare(`SELECT path, mtime_ms FROM doc_chunks WHERE origin = ?`).all(dir).map((r) => [r.path, r.mtime_ms])
   )
   const seen = new Set()
 
-  onProgress?.({ phase: "scan", total: files.length })
+  onProgress?.({ phase: "scan", total: files.length, overSizeSkipped })
 
   let updated = 0, removed = 0, skipped = 0, failed = 0
   const errors = []
   for (let i = 0; i < files.length; i++) {
-    const abs = files[i]
-    const rel = abs.slice(dir.length + 1).replaceAll("\\", "/")
+    const { abs, rel, mtimeMs } = files[i]
     seen.add(rel)
 
-    let mtimeMs
-    try { mtimeMs = Math.floor((await stat(abs)).mtimeMs) } catch { continue }
     if (indexed.get(rel) === mtimeMs) {
       skipped++
       continue
@@ -79,9 +69,9 @@ export async function docSync(memory, dir, { onProgress } = {}) {
     }
   }
 
-  onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed })
+  onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed, overSizeSkipped })
   markIndexedCommit(memory, dir)
-  return { updated, removed, skipped, failed, errors, total: files.length }
+  return { updated, removed, skipped, failed, errors, total: files.length, overSizeSkipped }
 }
 
 /**
@@ -141,8 +131,15 @@ export async function docSearch(memory, query, { limit = 5 } = {}) {
     .filter(Boolean)
 }
 
-/** Lazily backfill missing vectors for doc_chunks */
-export async function ensureDocEmbeddings(memory) {
+/** Lazily backfill missing vectors for doc_chunks. Guarded against concurrent calls. */
+let _docEmbedLock = null
+export function ensureDocEmbeddings(memory) {
+  if (_docEmbedLock) return _docEmbedLock
+  _docEmbedLock = _runEnsureDocEmbeddings(memory).finally(() => { _docEmbedLock = null })
+  return _docEmbedLock
+}
+
+async function _runEnsureDocEmbeddings(memory) {
   if (!memory.embedder) return
   const modelKey = memory.embedder.model
   const stored = memory.db.prepare(`SELECT value FROM meta WHERE key = 'doc_embedding_model'`).get()?.value

package/src/memory/schema.mjs

@@ -18,9 +18,22 @@ export const SQLITE_BUSY_TIMEOUT = 3000
 export const CODE_EXTS = new Set([".mjs", ".js", ".ts", ".tsx", ".jsx", ".py", ".rs", ".go", ".java", ".c", ".h", ".cpp", ".hpp", ".rb", ".swift", ".kt", ".sh", ".bash", ".sql", ".yaml", ".yml", ".toml", ".json", ".css", ".html", ".vue", ".svelte"])
 // Doc index: markdown / plain text (separate index makes it easier for LLM to distinguish "design specs" from "existing code")
 export const DOC_EXTS = new Set([".md", ".mdc", ".txt", ".rst", ".adoc"])
-// Directory names always skipped
-export const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".turbo", "coverage", "__pycache__", ".venv", "venv", "target", ".next", ".nuxt", ".svelte-kit"])
-// Large file threshold (lines): above this, chunk by symbol; otherwise index entire file
+// Directory names always skipped during code/doc indexing
+// NOTE: these are case-sensitive basename matches; add common platform-specific dirs
+export const SKIP_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".turbo", "coverage",
+  "__pycache__", ".venv", "venv", "target", ".next", ".nuxt", ".svelte-kit",
+  // Windows user profile directories (never contain project code)
+  "AppData", "Application Data", "Desktop", "Documents", "Downloads",
+  "Music", "Pictures", "Videos", "OneDrive", "Contacts", "Favorites",
+  "Links", "Saved Games", "Searches",
+  // Other common non-code directories
+  "Program Files", "Program Files (x86)", "Windows", "$Recycle.Bin",
+])
+// Files larger than these limits are skipped during bulk indexing
+// (minified bundles, test fixtures, generated code, etc.)
+export const MAX_CODE_FILE_BYTES = 1024 * 1024   // 1 MB
+export const MAX_DOC_FILE_BYTES  = 512 * 1024    // 512 KB
 export const BIG_FILE_LINES = 2000
 
 /**