thincoder 0.12.59 → 0.12.61

package/src/explore-distill.mjs

@@ -0,0 +1,155 @@
+/**
+ * explore-distill.mjs — End-of-run exploration distillation (AGENT-LOOP §13 +
+ * CONTEXT-COMPACTION §5, 2026-08-23). 2026-09-05 module-split: moved verbatim out of
+ * context.mjs (524 > 500 hard limit). The main agent's machine line is flooded by inline
+ * step-by-step exploration (read/grep/...). At run end we distill THIS run's exploration
+ * tool-results into one semantic summary note that replaces them in the machine line,
+ * while agent._fullHistory (the human line) stays untouched. VS Code compact.mjs
+ * distillation mirrors this module (same-name file in thincoder-vscode/src, cross-repo
+ * parity anchors point here).
+ */
+
+import { chat } from "./provider/index.mjs"
+
+/** Read-only knowledge tools counted as "exploration" (execute writes files → never exploration). */
+export const EXPLORE_TOOLS = new Set([
+  "read", "grep", "glob", "ls", "code_search", "doc_search", "repo_outline",
+])
+
+/** Summary prompt for turning a burst of exploration results into a semantic summary. */
+export const EXPLORE_SUMMARY_PROMPT = `You are distilling exploration tool results. Summarize the following read-only codebase exploration into a compact semantic summary for the main agent's own context.
+
+Requirements:
+- Capture WHAT was discovered, WHERE (which files / directories / symbols), and the KEY CONCLUSIONS — do not list tool calls mechanically
+- Keep actionable facts the main agent needs to continue: code locations, function names, file paths, structure, and open questions the exploration raised
+- Drop raw tool-output noise, repeated lines, and verbatim file dumps — keep only what must be remembered
+- Be honest: mark anything not actually verified as "unverified"; do not present guesses as facts
+- Use bullet points; aim for information completeness, not a hard word limit
+
+Exploration log:
+`
+
+/** tool_calls name across both stored shapes ({function:{name}} and flat {name}). */
+function toolCallName(tc) {
+  return tc?.function?.name ?? tc?.name ?? ""
+}
+
+/** Tool that produced a tool-result message (falls back to its owner assistant's tool_call). */
+function toolResultName(msg, ownerToolCalls) {
+  if (typeof msg?.name === "string" && msg.name) return msg.name
+  const owner = (ownerToolCalls ?? []).find((tc) => tc.id === msg?.tool_call_id)
+  return owner ? toolCallName(owner) : ""
+}
+
+/**
+ * Find the pure-exploration "assistant(tool_calls)→tool…" pair blocks added since `start`.
+ * A block is explorable only when EVERY tool call AND every tool result in it is an exploration
+ * tool — mixed blocks (read + edit in one turn) stay untouched, or we'd orphan the edit pairing.
+ */
+function findExplorationBlocks(history, start) {
+  const blocks = []
+  let i = start
+  while (i < history.length) {
+    const m = history[i]
+    if (m?.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      let j = i + 1
+      while (j < history.length && history[j]?.role === "tool") j++
+      const toolMsgs = history.slice(i + 1, j)
+      const allCallsExplore = m.tool_calls.every((tc) => EXPLORE_TOOLS.has(toolCallName(tc)))
+      const allResultsExplore = toolMsgs.length > 0 && toolMsgs.every((t) => EXPLORE_TOOLS.has(toolResultName(t, m.tool_calls)))
+      if (allCallsExplore && allResultsExplore) {
+        blocks.push({ start: i, end: j, messages: history.slice(i, j), toolCount: toolMsgs.length })
+      }
+      i = j
+    } else {
+      i++
+    }
+  }
+  return blocks
+}
+
+/** Serialize a batch of exploration messages for the summary LLM (same shape as compaction serialization). */
+function serializeExplorationMessages(messages) {
+  const cap = 8000 // exploration results ARE the signal to distill — generous cap (quality-first, N1)
+  return messages
+    .map((m) => {
+      const toolNote = m.tool_calls ? ` [called tools: ${m.tool_calls.map(toolCallName).join(", ")}]` : ""
+      let text = ""
+      if (typeof m.content === "string") text = m.content
+      else if (Array.isArray(m.content)) text = m.content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join(" ")
+      return `[${m.role}]${toolNote} ${text.slice(0, cap)}`
+    })
+    .join("\n")
+}
+
+/**
+ * Core (shared) distillation: replace this run's pure-exploration pair blocks with a single
+ * "[Exploration summary]" note placed where the first block was. Returns a NEW history array,
+ * or null when there is nothing to shrink (<3 exploration results / LLM failure). Pairing-safe:
+ * whole assistant→tool blocks are removed, so no orphan tool_calls/tool can survive.
+ */
+async function distillExplorations(history, start, provider, signal, agent, depth) {
+  if (!Array.isArray(history) || history.length - start < 2) return null
+  const blocks = findExplorationBlocks(history, start)
+  const resultCount = blocks.reduce((n, b) => n + b.toolCount, 0)
+  if (resultCount < 3) return null
+
+  const serialized = blocks.map((b) => serializeExplorationMessages(b.messages)).join("\n")
+
+  let summary
+  try {
+    // Silent by design (D11): thinking:null and no onToken/onReasoning — this internal
+    // distillation must not stream to the frontend. signal propagates user cancellation.
+    const resp = await chat({ ...provider, thinking: null, reasoningEffort: null }, {
+      messages: [{ role: "user", content: EXPLORE_SUMMARY_PROMPT + serialized }],
+      signal,
+      // §18.6 D-TR4：轨迹元数据增补——kind=distill（探索蒸馏面——agent 元数据透出；
+      // depth 经 summarizeRunExplorations 参数透传——agent.mjs 主作用域传入）
+      logCtx: {
+        stage: "distill", child: agent?._logId ?? null, kind: "distill",
+        role: agent?._role ?? null, depth: depth ?? null,
+        session: agent?._sessionStart ?? null, cwd: agent?.cwd ?? process.cwd(),
+        traces: agent?.config?.traces?.enabled !== false,
+      },
+    })
+    summary = resp?.content
+  } catch {
+    return null // N3: never block the run's return or lose history — original results stay
+  }
+  if (!summary) return null
+
+  const drop = new Set()
+  for (const b of blocks) for (let k = b.start; k < b.end; k++) drop.add(k)
+  const note = { role: "user", content: "[Exploration summary]\n" + summary }
+  const next = []
+  let inserted = false
+  for (let k = 0; k < history.length; k++) {
+    if (drop.has(k)) {
+      if (!inserted) { next.push(note); inserted = true }
+      continue
+    }
+    next.push(history[k])
+  }
+  return next
+}
+
+/**
+ * End-of-run exploration distillation (runAgent's final return). Shrinks the MACHINE line
+ * (agent.history) only; agent._fullHistory is never touched. Triggers when this run added ≥3
+ * exploration tool results; on LLM failure it silently keeps the original history (N3).
+ * The distillation itself is silent and never streams (D11); `callbacks.onDistilled` fires
+ * ONLY after the replacement actually lands (never on no-op/failure) — callers persist the
+ * compressed session (SEND-STALL-DISTILL §2.3).
+ */
+export async function summarizeRunExplorations(agent, callbacks, signal, depth = 0) {
+  const next = await distillExplorations(agent.history, agent._runStartHistoryLen ?? 0, agent.provider, signal, agent, depth)
+  if (!next) return
+  agent.history = next
+  // The machine line changed shape — the measured token baseline was for the pre-shrink context.
+  // Invalidate so the next compaction check re-estimates instead of over-counting stale history.
+  agent._lastPromptTokens = null
+  agent._usageAtLen = null
+  // The compressed machine line must reach the disk: the run's own save already happened,
+  // so without this hook the async distill would leave the session un-compressed on exit.
+  callbacks.onDistilled?.()
+}

package/src/generate-title.mjs

@@ -46,7 +46,7 @@ export async function generateTitle(userContent, provider) {
     const url = `${provider.baseURL.replace(/\/+$/, "")}${chatPath}`
     const opts = {
       method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${provider.apiKey}` },
+      headers: { ...(provider.headers ?? {}), "Content-Type": "application/json", Authorization: `Bearer ${provider.apiKey}` }, // 定制头展开（PROVIDER.md §21）——定制头在前、内置头在后：内置头胜出
       body,
       signal: AbortSignal.timeout(10000),
     }

package/src/hooks.mjs

@@ -8,7 +8,7 @@
  *   PreToolUse          — before each tool call (can block execution)
  *   PostToolUse         — after successful tool execution
  *   PostToolUseFailure  — after failed tool execution
- *   Notification        — generic notification (triggered by agent)
+ *   Stop                — main-session run end (no tool name; block is meaningless)
  *
  * Each hook: { matcher?, command, args?, timeout?, action? }
  *   matcher: regex against tool name (default: match all)
@@ -29,9 +29,11 @@ export async function runHooks(event, ctx) {
   if (!hooks?.length) return true
 
   for (const hook of hooks) {
-    if (hook.matcher) {
+    // Matcher = tool-name regex: tool events always carry a toolName; no-tool-name
+    // events (Stop) ignore it — a configured matcher must not silently never fire.
+    if (hook.matcher && ctx.toolName != null) {
       try {
-        if (!new RegExp(hook.matcher).test(ctx.toolName ?? "")) continue
+        if (!new RegExp(hook.matcher).test(ctx.toolName)) continue
       } catch { /* invalid regex → skip */ }
     }
 
@@ -48,6 +50,8 @@ async function runOneHook(event, hook, ctx) {
     toolArgs: ctx.toolArgs ?? null,
     result: ctx.result ?? null,
     error: ctx.error?.message ?? null,
+    // Event-specific fields (Stop: turn / reason) — existing callers pass no extra ⇒ payload unchanged.
+    ...(ctx.extra ?? {}),
     timestamp: new Date().toISOString(),
   })
 

package/src/memory/code-index.mjs

@@ -8,14 +8,20 @@ import { segmentCJK, CODE_EXTS, DOC_EXTS, SKIP_DIRS, BIG_FILE_LINES } from "./sc
 export function detectLanguage(filename) {
   const ext = filename.slice(filename.lastIndexOf(".")).toLowerCase()
   const map = {
-    ".mjs": "javascript", ".js": "javascript", ".jsx": "jsx", ".ts": "typescript", ".tsx": "tsx",
+    ".mjs": "javascript", ".js": "javascript", ".cjs": "javascript", ".jsx": "jsx",
+    ".ts": "typescript", ".tsx": "tsx", ".mts": "typescript", ".cts": "typescript",
     ".py": "python", ".rs": "rust", ".go": "go", ".java": "java",
     ".c": "c", ".h": "c", ".cpp": "cpp", ".hpp": "cpp",
-    ".rb": "ruby", ".swift": "swift", ".kt": "kotlin",
+    ".rb": "ruby", ".swift": "swift", ".kt": "kotlin", ".dart": "dart", ".lua": "lua",
+    ".cs": "csharp", ".fs": "fsharp", ".fsx": "fsharp",
+    ".clj": "clojure", ".cljs": "clojure", ".ex": "elixir", ".exs": "elixir",
+    ".erl": "erlang", ".hrl": "erlang", ".scala": "scala", ".groovy": "groovy",
+    ".pl": "perl", ".pm": "perl", ".r": "r", ".jl": "julia", ".zig": "zig",
+    ".ps1": "powershell", ".proto": "protobuf", ".graphql": "graphql", ".tf": "terraform", ".hcl": "hcl",
     ".sh": "bash", ".bash": "bash", ".sql": "sql",
     ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".json": "json",
     ".css": "css", ".html": "html", ".vue": "vue", ".svelte": "svelte",
-    ".md": "markdown", ".mdc": "markdown",
+    ".md": "markdown", ".mdc": "markdown", ".mdx": "markdown", ".org": "org", ".wiki": "wiki", ".tex": "tex",
   }
   return map[ext] ?? ext.slice(1)
 }

package/src/memory/code-sync.mjs

@@ -4,13 +4,30 @@
 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, MAX_CODE_FILE_BYTES, MAX_DOC_FILE_BYTES } from "./schema.mjs"
+import { CODE_EXTS, DOC_EXTS, 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"
+import { walkProjectFiles, isSkippedRelPath, extensionOf, createUnlistedTally, MAX_WALK_FILES } from "./file-walk.mjs"
+import { loadConventions } from "../conventions.mjs"
+import { logEvent } from "../log.mjs"
 
 const DIFF_FULL_SYNC_THRESHOLD = 200
 const CODE_EMBED_BATCH = 64
 
+/**
+ * Index extension sets = built-in tables ∪ project declaration
+ * (`.thincoder/conventions.json` → index.codeExtensions / index.docExtensions;
+ * PORTABILITY PO-9/§3.7 — a project may declare extensions this product does not
+ * ship a default for). Declaration only ADDS (union), never removes.
+ */
+export function indexExtensions(dir) {
+  const conv = loadConventions(dir)
+  return {
+    code: new Set([...CODE_EXTS, ...conv.index.codeExtensions]),
+    doc: new Set([...DOC_EXTS, ...conv.index.docExtensions]),
+  }
+}
+
 /**
  * git-driven incremental indexing: use git diff to find files changed since
  * the last index, and only rebuild FTS5 chunks for those files (vectors are untouched).
@@ -19,6 +36,7 @@ const CODE_EMBED_BATCH = 64
  */
 export async function gitSync(memory, dir, { onProgress } = {}) {
   const { execFile: _execFile } = await import("node:child_process")
+  const { code: codeExts, doc: docExts } = indexExtensions(dir)
   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)
@@ -55,17 +73,16 @@ export async function gitSync(memory, dir, { onProgress } = {}) {
   for (let i = 0; i < diffOut.length; i++) {
     const rel = diffOut[i].replaceAll("\\", "/")
     const abs = join(dir, rel)
-    const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
+    const ext = extensionOf(rel)
 
-    const pathDirs = rel.split("/")
-    if (pathDirs.some((d) => SKIP_DIRS.has(d) || d.startsWith("."))) continue
+    if (isSkippedRelPath(rel)) continue
 
-    if (!CODE_EXTS.has(ext) && !DOC_EXTS.has(ext)) { skipped++; continue }
+    if (!codeExts.has(ext) && !docExts.has(ext)) { skipped++; continue }
 
     try {
       const text = await readFile(abs, "utf8")
       const lines = text.split("\n")
-      if (CODE_EXTS.has(ext)) {
+      if (codeExts.has(ext)) {
         const lang = detectLanguage(abs)
         let mtimeMs = 0
         try { mtimeMs = Math.floor((await stat(abs)).mtimeMs) } catch { /* new file */ }
@@ -79,7 +96,7 @@ export async function gitSync(memory, dir, { onProgress } = {}) {
     } catch (e) {
       const isDeleted = e.code === "ENOENT"
       if (isDeleted) {
-        if (CODE_EXTS.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(dir, rel)
+        if (codeExts.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(dir, rel)
         else memory.db.prepare(`DELETE FROM doc_chunks WHERE origin = ? AND path = ?`).run(dir, rel)
         removed++
       } else {
@@ -104,16 +121,27 @@ export async function gitSync(memory, dir, { onProgress } = {}) {
 
 /**
  * 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).
+ * Preferred source = git (`git ls-files --cached --others --exclude-standard`:
+ * tracked + untracked-not-ignored, .gitignore respected). Projects WITHOUT git
+ * fall back to a filesystem walk (PORTABILITY FR15/P8) — before, the index was
+ * silently empty there. The walk cannot honour .gitignore (no git → no such
+ * concept) and skips the shared SKIP_DIRS/dot-directory set instead.
+ * Returns { entries, unlisted }: `entries` = { abs, rel } pairs (rel relative to
+ * dir); `unlisted` = files whose extension is in NO index list (count + sample),
+ * the visible signal behind "my .xyz files are not searchable" (PORTABILITY PO-9).
+ * `truncated` = the non-git walk hit its file cap (capped trees are logged, never
+ * silently indexed-partial). opts.maxFiles = the walk cap (test seam).
  */
-export async function listProjectFiles(dir, exts) {
+export async function listProjectFiles(dir, exts, { maxFiles } = {}) {
   const { execFile: _execFile } = await import("node:child_process")
   const { join: joinPath } = await import("node:path")
+  const { code, doc } = indexExtensions(dir)
+  const tally = createUnlistedTally(new Set([...code, ...doc]))
 
-  // Only index git repos — if this isn't one, return empty
+  const files = []
+  const finish = (truncated = false) => ({ entries: files, unlisted: tally.result(), truncated })
+
+  // Git listing when available; a non-git project falls through to the walk.
   let gitTop
   try {
     gitTop = (await new Promise((resolve, reject) => {
@@ -121,10 +149,17 @@ export async function listProjectFiles(dir, exts) {
         (err, stdout) => { if (err) reject(err); else resolve(stdout.trim()) })
     })).replace(/\\/g, "/")
   } catch {
-    return [] // not a git repo → nothing to index
+    // Not a git repo → filesystem walk (FR15: the index must still be usable).
+    const walked = await walkProjectFiles(dir, exts, { knownExts: new Set([...code, ...doc]), ...(maxFiles !== undefined ? { maxFiles } : {}) })
+    files.push(...walked.files)
+    // The walk's cap must stay visible end-to-end (file-walk.mjs: "never silently
+    // dropped") — a capped listing says so in the log, not only in a discarded flag.
+    if (walked.truncated) {
+      logEvent("index:truncated", { dir, files: walked.files.length, maxFiles: maxFiles ?? MAX_WALK_FILES })
+    }
+    return { entries: files, unlisted: walked.unlisted, truncated: walked.truncated }
   }
 
-  const files = []
   try {
     const raw = await new Promise((resolve, reject) => {
       _execFile("git", ["ls-files", "--cached", "--others", "--exclude-standard"],
@@ -134,16 +169,15 @@ export async function listProjectFiles(dir, exts) {
     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 })
+      if (isSkippedRelPath(rel)) continue
+      const ext = extensionOf(rel)
+      if (!ext || !exts.has(ext)) { tally.note(rel); continue }
+      files.push({ abs: joinPath(dir, rel), rel })
     }
   } catch { /* ls-files failed */ }
 
-  return files
+  return finish()
 }
 
 
@@ -152,7 +186,8 @@ export async function listProjectFiles(dir, exts) {
  * Incremental by mtime — only rebuilds chunks for files that have changed.
  */
 export async function codeSync(memory, dir, { onProgress } = {}) {
-  const entries = await listProjectFiles(dir, CODE_EXTS)
+  const { code: exts } = indexExtensions(dir)
+  const { entries, unlisted } = await listProjectFiles(dir, exts)
   const files = [] // { abs, rel, mtimeMs }
   let overSizeSkipped = 0
   for (const { abs, rel } of entries) {
@@ -206,7 +241,10 @@ export async function codeSync(memory, dir, { onProgress } = {}) {
 
   onProgress?.({ phase: "done", total: files.length, updated, removed, skipped, failed, overSizeSkipped })
   markIndexedCommit(memory, dir)
-  return { updated, removed, skipped, failed, errors, total: files.length, overSizeSkipped }
+  if (unlisted.count > 0) {
+    logEvent("index:unlisted", { dir, kind: "code", count: unlisted.count, exts: unlisted.exts.map((e) => e.ext) })
+  }
+  return { updated, removed, skipped, failed, errors, total: files.length, overSizeSkipped, unlistedExts: unlisted }
 }
 
 /** Record current HEAD as the index anchor (gitSync incremental diff baseline); silently skip non-git repos */
@@ -313,7 +351,8 @@ export function codeSearchTool(memory) {
   return {
     name: "code_search",
     description:
-      "Search the project's source code for relevant code. Use this to find functions, classes, or code patterns across the codebase. Supports natural language queries and code snippets. Returns matching code chunks with file paths and line numbers. Prefer doc_search for the intended design (design docs, conventions); code_search for the implementation as written.",
+      "Search the project's source code for relevant code. Use this to find functions, classes, or code patterns across the codebase. Supports natural language queries and code snippets. Returns matching code chunks with file paths and line numbers. Prefer doc_search for the intended design (design docs, conventions); code_search for the implementation as written. " +
+      "For what was said in a session (conversation/chat history), use read_history.",
     parameters: {
       type: "object",
       properties: {
@@ -337,32 +376,33 @@ export function codeSearchTool(memory) {
  * Single-file incremental reindex: called after write/edit/delete, only rebuilds this one path.
  */
 export async function reindexFile(memory, cwd, absPath) {
-  const ext = absPath.slice(absPath.lastIndexOf(".")).toLowerCase()
+  const ext = extensionOf(absPath)
   const rel = relative(cwd, absPath).replaceAll("\\", "/")
   if (rel === ".." || rel.startsWith("../")) return
-  const dirs = rel.split("/").slice(0, -1)
-  if (dirs.some((d) => SKIP_DIRS.has(d) || d.startsWith("."))) return
+  if (isSkippedRelPath(rel)) return
+  // Declared extensions count for the single-file path too (union with built-ins).
+  const { code: codeExts, doc: docExts } = indexExtensions(cwd)
 
   // 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
+  const maxBytes = codeExts.has(ext) ? MAX_CODE_FILE_BYTES : docExts.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)
-    else if (DOC_EXTS.has(ext)) memory.db.prepare(`DELETE FROM doc_chunks WHERE origin = ? AND path = ?`).run(cwd, rel)
+    if (codeExts.has(ext)) memory.db.prepare(`DELETE FROM code_chunks WHERE origin = ? AND path = ?`).run(cwd, rel)
+    else if (docExts.has(ext)) memory.db.prepare(`DELETE FROM doc_chunks WHERE origin = ? AND path = ?`).run(cwd, rel)
     return
   }
   const lines = text.split("\n")
 
-  if (CODE_EXTS.has(ext)) {
+  if (codeExts.has(ext)) {
     const lang = detectLanguage(absPath)
     let mtimeMs = 0
     try { mtimeMs = Math.floor((await stat(absPath)).mtimeMs) } catch { /* new file */ }
     _upsertCodeFile(memory, cwd, rel, lines, lang, mtimeMs)
-  } else if (DOC_EXTS.has(ext)) {
+  } else if (docExts.has(ext)) {
     let mtimeMs = 0
     try { mtimeMs = Math.floor((await stat(absPath)).mtimeMs) } catch { /* new file */ }
     _upsertDocFile(memory, cwd, rel, lines, mtimeMs)