@duckmind/dm-windows-x64 0.60.6 → 0.60.9

package/extensions/dm-fff/src/index.js

@@ -1,15 +1,691 @@
-import{Text as L}from"@duckmind/dm-tui";import{FileFinder as Kj}from"@ff-labs/fff-node";import{Type as W}from"@sinclair/typebox";import w from"node:path";function c(J,$=process.cwd()){let Z=J.trim();if(!Z)return Z;if(w.isAbsolute(Z)){let k=w.relative($,Z).replaceAll(w.sep,"/");if(k==="")return null;if(k.startsWith("../")||k===".."||w.isAbsolute(k))throw Error(`Path constraint must be relative to the workspace: ${J}`);Z=k}if(Z==="."||Z==="./")return null;if(Z.startsWith("./"))Z=Z.slice(2);let G=Z.match(/^(.*)\/\*\*(?:\/\*)?$/);if(G){let k=G[1];if(k&&!/[*?[{]/.test(k))return`${k}/`}if(Z.startsWith("/")||Z.endsWith("/"))return Z;if(/[*?[{]/.test(Z))return Z;let B=Z.split("/").pop()??"";if(/\.[a-zA-Z][a-zA-Z0-9]{0,9}$/.test(B))return Z;return`${Z}/`}function $j(J,$=process.cwd()){if(!J)return[];let Z=Array.isArray(J)?J:[J],G=[];for(let B of Z){let k=B.split(/[,\s]+/).map((V)=>V.trim()).filter(Boolean);for(let V of k){let z=V.startsWith("!")?V.slice(1):V,P=c(z,$);if(P)G.push(`!${P}`)}}return G}function x(J,$,Z,G=process.cwd()){let B=[];if(J){let k=c(J,G);if(k)B.push(k)}return B.push(...$j(Z,G)),B.push($),B.join(" ")}var E=20,f=30,Zj=500,p=20,h=["tools-and-ui","tools-only","override"],Hj={grep:"ffgrep",find:"fffind",multiGrep:"fff-multi-grep"},Qj={grep:"grep",find:"find",multiGrep:"multi_grep"};function Wj(J){return J==="override"?Qj:Hj}var _=new Map,Yj=0;function u(J){let $=`fff_c${++Yj}`;if(_.set($,J),_.size>200){let Z=_.keys().next().value;if(Z)_.delete(Z)}return $}function d(J){return _.get(J)}var M=new Map,Bj=0;function Xj(J){let $=`${++Bj}`;if(M.set($,J),M.size>200){let Z=M.keys().next().value;if(Z)M.delete(Z)}return $}function kj(J){return M.get(J)}function l(J,$=Zj){let Z=J.trim();return Z.length<=$?Z:`${Z.slice(0,$)}...`}var qj=25,Vj=20;function n(J){let $=J.gitStatus;if($&&$!=="clean"&&$!=="unknown"&&$!=="")return`  [${$} in git]`;let Z=J.totalFrecencyScore??J.accessFrecencyScore??0;if(Z>=qj)return"  [VERY often touched file]";if(Z>=Vj)return"  [often touched file]";return""}function o(J){if(J.items.length===0)return"No matches found";let $=[],Z="",G=0;for(let B of J.items){if(B.relativePath!==Z){if($.length>0)$.push("");Z=B.relativePath,$.push(`${Z}${n(B)}`)}B.contextBefore?.forEach((k,V)=>{let z=B.lineNumber-B.contextBefore.length+V;$.push(` ${z}- ${l(k)}`)}),$.push(` ${B.lineNumber}: ${l(B.lineContent)}`),G++,B.contextAfter?.forEach((k,V)=>{let z=B.lineNumber+1+V;$.push(` ${z}- ${l(k)}`)})}return $.join(`
-`)}var Uj=5;function Gj(J){let $=J.length*12;return Math.floor($*50/100)}function bj(J,$,Z){if(J.items.length===0)return{output:"No files found matching pattern",weak:!1,shownCount:0};let G=J.items.map((P)=>({item:P})),k=(J.scores[0]?.total??0)<Gj(Z),V=k?Math.min(Uj,$):$,z=G.slice(0,V);return{output:z.map((P)=>`${P.item.relativePath}${n(P.item)}`).join(`
-`),weak:k,shownCount:z.length}}function Oj(J){return J.match(/(?:^|[ \t])(@(?:"[^"]*|[^\s]*))$/)?.[1]??null}function m(J){return J.includes(" ")?`@"${J}"`:`@${J}`}function zj(J){return{async getSuggestions($,Z,G,B){let k=$[Z]||"",V=Oj(k.slice(0,G));if(!V||B.signal.aborted)return null;let z=V.startsWith('@"')?V.slice(2):V.slice(1),P=await J(z,B.signal);return B.signal.aborted||P.length===0?null:{items:P,prefix:V}},applyCompletion($,Z,G,B,k){let V=$[Z]||"",z=V.slice(0,G-k.length),P=V.slice(G),C=z+B.value+P,y=G-k.length+B.value.length;return{lines:[...$.slice(0,Z),C,...$.slice(Z+1)],cursorLine:Z,cursorCol:y}}}}function Pj(J){let $=null,Z=null,G=null,B=process.cwd(),k=J.getFlag("fff-mode")??process.env.DM_FFF_MODE??"tools-and-ui",V=Wj(k),z=J.getFlag("fff-frecency-db")??process.env.FFF_FRECENCY_DB??void 0,P=J.getFlag("fff-history-db")??process.env.FFF_HISTORY_DB??void 0;function C(Y,j){let K=J.getFlag(Y);if(typeof K==="boolean")return K;if(typeof K==="string")return K==="true"||K==="1";let H=process.env[j];return H==="1"||H==="true"}let y=C("fff-enable-root-scan","FFF_ENABLE_ROOT_SCAN");function T(){return k}function a(Y){k=Y}function i(){return k!=="tools-only"}function F(Y){if($&&!$.isDestroyed&&Z===Y)return Promise.resolve($);if(G)return G;return G=(async()=>{if($&&!$.isDestroyed)$.destroy(),$=null,Z=null;let j=Kj.create({basePath:Y,frecencyDbPath:z,historyDbPath:P,aiMode:!0,enableHomeDirScanning:!0,enableFsRootScanning:y});if(!j.ok)throw Error(`Failed to create FFF file finder: ${j.error}`);return $=j.value,Z=Y,await $.waitForScan(15000),$})().finally(()=>{G=null}),G}function s(){if($&&!$.isDestroyed)$.destroy(),$=null,Z=null}async function r(Y,j){if(j.aborted)return[];let K=await F(B);if(j.aborted)return[];let H=K.mixedSearch(Y,{pageSize:p});if(!H.ok)return[];return H.value.items.slice(0,p).map((Q)=>{if(Q.type==="directory")return{value:m(Q.item.relativePath),label:Q.item.dirName,description:Q.item.relativePath};return{value:m(Q.item.relativePath),label:Q.item.fileName,description:Q.item.relativePath}})}function t(Y){Y.ui.addAutocompleteProvider((j)=>{let K=zj(r);return{async getSuggestions(H,Q,X,U){if(i())try{let q=await K.getSuggestions(H,Q,X,U);if(q)return q}catch{}return j.getSuggestions(H,Q,X,U)},applyCompletion(H,Q,X,U,q){return j.applyCompletion(H,Q,X,U,q)},shouldTriggerFileCompletion(H,Q,X){return j.shouldTriggerFileCompletion?.(H,Q,X)??!0}}})}J.registerFlag("fff-mode",{description:"FFF mode: tools-and-ui | tools-only | override",type:"string"}),J.registerFlag("fff-frecency-db",{description:"Path to the frecency database (overrides FFF_FRECENCY_DB env)",type:"string"}),J.registerFlag("fff-history-db",{description:"Path to the query history database (overrides FFF_HISTORY_DB env)",type:"string"}),J.registerFlag("fff-enable-root-scan",{description:"Allow indexing when launched from the filesystem root (also: FFF_ENABLE_ROOT_SCAN env)",type:"boolean"}),J.on("session_start",async(Y,j)=>{try{B=j.cwd;let K=j.sessionManager?.getEntries();if(K){let H=[...K].reverse().find((Q)=>Q.type==="custom"&&Q.customType==="fff-mode");if(H&&typeof H.data?.mode==="string"&&h.includes(H.data.mode)){let Q=H.data.mode;if(Q!==k)k=Q}}t(j),await F(B)}catch(K){j.ui.notify(`FFF init failed: ${K instanceof Error?K.message:String(K)}`,"error")}}),J.on("session_shutdown",async()=>{s()});let g=(Y,j,K,H,Q=15)=>{let X=H.lastComponent??new L("",0,0),U=Y.content?.find((O)=>O.type==="text")?.text?.trim()??"";if(!U)return X.setText(K.fg("muted","No output")),X;let q=U.split(`
-`),b=q.slice(0,j.expanded?q.length:Q),S=`
-${b.map((O)=>K.fg("toolOutput",O)).join(`
-`)}`;if(q.length>b.length)S+=K.fg("muted",`
-... (${q.length-b.length} more lines)`);return X.setText(S),X},e=W.Object({pattern:W.String({description:"Search pattern (literal text or regex)"}),path:W.Optional(W.String({description:"Repo-relative path constraint. Directory prefix (src/ or src/foo/), bare filename with extension (main.rs), or glob (*.ts, src/**/*.cc, {src,lib}/**). Applied to the full repo-relative path."})),exclude:W.Optional(W.Union([W.String(),W.Array(W.String())],{description:"Exclude paths (comma/space-separated or array). Same syntax as path: directory prefix ('test/'), filename with extension ('config.json'), or glob ('*.min.js', '**/*.{rs,go}'). A leading '!' is optional and ignored — both 'test/' and '!test/' work. Example: 'test/,*.min.js,!vendor/'."})),caseSensitive:W.Optional(W.Boolean({description:"Force case-sensitive matching. Default uses smart-case (case-insensitive when pattern is all lowercase)."})),context:W.Optional(W.Number({description:"Context lines before+after each match"})),limit:W.Optional(W.Number({description:`Max matches (default ${E})`})),cursor:W.Optional(W.String({description:"Pagination cursor from previous result"}))});J.registerTool({name:V.grep,label:V.grep,description:`Grep file contents. Smart-case, auto-detects regex vs literal, git-aware. Results are ranked by frecency (most-accessed files first); matches within a file stay in source order. Default limit ${E}.`,promptSnippet:"Grep contents",promptGuidelines:["Prefer bare identifiers as patterns. Literal queries are most efficient.","Use path for include ('src/', '*.ts') and exclude for noise ('test/,*.min.js').","caseSensitive: true when you need exact case (smart-case otherwise).","After 1-2 greps, read the top match instead of more greps."],parameters:e,async execute(Y,j,K){if(K?.aborted)throw Error("Operation aborted");let H=await F(B),Q=Math.max(1,j.limit??E),X=x(j.path,j.pattern,j.exclude,B),U=j.pattern!==j.pattern.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),q=U?"regex":"plain";if(q==="regex")try{new RegExp(j.pattern)}catch{q="plain"}let b=j.pattern.trim();if(U&&/^(?:[.^$]*(?:[.][*+?]|\*|\+)[.^$]*|[.^$\s]*|\.\*\??|\.\*[+?]?|\.\+\??|\.|\*|\?)$/.test(b))return{content:[{type:"text",text:`Pattern '${j.pattern}' matches everything — grep needs a concrete substring or identifier. Example: \`pattern: 'MyClass'\` or \`pattern: 'export function'\`.`}],details:{totalMatched:0,totalFiles:0}};let O=j.caseSensitive!==!0,A=H.grep(X,{mode:q,smartCase:O,maxMatchesPerFile:Math.min(Q,50),cursor:(j.cursor?d(j.cursor):null)??null,beforeContext:j.context??0,afterContext:j.context??0,classifyDefinitions:!0});if(!A.ok)throw Error(A.error);let D=A.value,v=null;if(D.items.length===0&&!j.cursor&&q!=="regex"){let I=H.grep(j.pattern,{mode:"fuzzy",smartCase:O,maxMatchesPerFile:Math.min(Q,50),cursor:null,beforeContext:0,afterContext:0,classifyDefinitions:!0});if(I.ok&&I.value.items.length>0)v="0 exact matches. Maybe you meant this?",D=I.value}let N=o(D),R=[];if(D.regexFallbackError)R.push(`Invalid regex: ${D.regexFallbackError}, used literal match`);if(D.nextCursor)R.push(`Continue with cursor="${u(D.nextCursor)}"`);if(R.length>0)N+=`
+import {
+  Text
+} from "@duckmind/dm-tui";
+import { FileFinder } from "@ff-labs/fff-node";
+import { Type } from "@sinclair/typebox";
+import { buildQuery } from "./query";
+const DEFAULT_GREP_LIMIT = 20;
+const DEFAULT_FIND_LIMIT = 30;
+const GREP_MAX_LINE_LENGTH = 500;
+const MENTION_MAX_RESULTS = 20;
+const VALID_MODES = ["tools-and-ui", "tools-only", "override"];
+const FFF_TOOL_NAMES = {
+  grep: "ffgrep",
+  find: "fffind",
+  multiGrep: "fff-multi-grep"
+};
+const OVERRIDE_TOOL_NAMES = {
+  grep: "grep",
+  find: "find",
+  multiGrep: "multi_grep"
+};
+function resolveToolNames(mode) {
+  return mode === "override" ? OVERRIDE_TOOL_NAMES : FFF_TOOL_NAMES;
+}
+const cursorCache = new Map;
+let cursorCounter = 0;
+function storeCursor(cursor) {
+  const id = `fff_c${++cursorCounter}`;
+  cursorCache.set(id, cursor);
+  if (cursorCache.size > 200) {
+    const first = cursorCache.keys().next().value;
+    if (first)
+      cursorCache.delete(first);
+  }
+  return id;
+}
+function getCursor(id) {
+  return cursorCache.get(id);
+}
+const findCursorCache = new Map;
+let findCursorCounter = 0;
+function storeFindCursor(cursor) {
+  const id = `${++findCursorCounter}`;
+  findCursorCache.set(id, cursor);
+  if (findCursorCache.size > 200) {
+    const first = findCursorCache.keys().next().value;
+    if (first)
+      findCursorCache.delete(first);
+  }
+  return id;
+}
+function getFindCursor(id) {
+  return findCursorCache.get(id);
+}
+function truncateLine(line, max = GREP_MAX_LINE_LENGTH) {
+  const trimmed = line.trim();
+  return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max)}...`;
+}
+const HOT_FRECENCY = 25;
+const WARM_FRECENCY = 20;
+export function fffFileAnnotation(item) {
+  const git = item.gitStatus;
+  if (git && git !== "clean" && git !== "unknown" && git !== "") {
+    return `  [${git} in git]`;
+  }
+  const frecency = item.totalFrecencyScore ?? item.accessFrecencyScore ?? 0;
+  if (frecency >= HOT_FRECENCY)
+    return "  [VERY often touched file]";
+  if (frecency >= WARM_FRECENCY)
+    return "  [often touched file]";
+  return "";
+}
+function formatGrepOutput(result) {
+  if (result.items.length === 0)
+    return "No matches found";
+  const lines = [];
+  let currentFile = "";
+  let shown = 0;
+  for (const match of result.items) {
+    if (match.relativePath !== currentFile) {
+      if (lines.length > 0)
+        lines.push("");
+      currentFile = match.relativePath;
+      lines.push(`${currentFile}${fffFileAnnotation(match)}`);
+    }
+    match.contextBefore?.forEach((line, i) => {
+      const lineNum = match.lineNumber - match.contextBefore.length + i;
+      lines.push(` ${lineNum}- ${truncateLine(line)}`);
+    });
+    lines.push(` ${match.lineNumber}: ${truncateLine(match.lineContent)}`);
+    shown++;
+    match.contextAfter?.forEach((line, i) => {
+      const lineNum = match.lineNumber + 1 + i;
+      lines.push(` ${lineNum}- ${truncateLine(line)}`);
+    });
+  }
+  return lines.join(`
+`);
+}
+const FIND_WEAK_SAMPLE_SIZE = 5;
+function weakScoreThreshold(pattern) {
+  const perfect = pattern.length * 12;
+  return Math.floor(perfect * 50 / 100);
+}
+function formatFindOutput(result, limit, pattern) {
+  if (result.items.length === 0) {
+    return {
+      output: "No files found matching pattern",
+      weak: false,
+      shownCount: 0
+    };
+  }
+  const reordered = result.items.map((item) => ({ item }));
+  const topScore = result.scores[0]?.total ?? 0;
+  const weak = topScore < weakScoreThreshold(pattern);
+  const effective = weak ? Math.min(FIND_WEAK_SAMPLE_SIZE, limit) : limit;
+  const shown = reordered.slice(0, effective);
+  return {
+    output: shown.map((p) => `${p.item.relativePath}${fffFileAnnotation(p.item)}`).join(`
+`),
+    weak,
+    shownCount: shown.length
+  };
+}
+function extractAtPrefix(textBeforeCursor) {
+  const match = textBeforeCursor.match(/(?:^|[ \t])(@(?:"[^"]*|[^\s]*))$/);
+  return match?.[1] ?? null;
+}
+function buildAtCompletionValue(path) {
+  return path.includes(" ") ? `@"${path}"` : `@${path}`;
+}
+function createFffMentionProvider(getItems) {
+  return {
+    async getSuggestions(lines, cursorLine, cursorCol, options) {
+      const currentLine = lines[cursorLine] || "";
+      const prefix = extractAtPrefix(currentLine.slice(0, cursorCol));
+      if (!prefix || options.signal.aborted)
+        return null;
+      const query = prefix.startsWith('@"') ? prefix.slice(2) : prefix.slice(1);
+      const items = await getItems(query, options.signal);
+      return options.signal.aborted || items.length === 0 ? null : { items, prefix };
+    },
+    applyCompletion(_lines, cursorLine, cursorCol, item, prefix) {
+      const currentLine = _lines[cursorLine] || "";
+      const before = currentLine.slice(0, cursorCol - prefix.length);
+      const after = currentLine.slice(cursorCol);
+      const newLine = before + item.value + after;
+      const newCursorCol = cursorCol - prefix.length + item.value.length;
+      return {
+        lines: [..._lines.slice(0, cursorLine), newLine, ..._lines.slice(cursorLine + 1)],
+        cursorLine,
+        cursorCol: newCursorCol
+      };
+    }
+  };
+}
+export default function fffExtension(dm) {
+  let finder = null;
+  let finderCwd = null;
+  let finderPromise = null;
+  let activeCwd = process.cwd();
+  let currentMode = dm.getFlag("fff-mode") ?? process.env.DM_FFF_MODE ?? "tools-and-ui";
+  const toolNames = resolveToolNames(currentMode);
+  const frecencyDbPath = dm.getFlag("fff-frecency-db") ?? process.env.FFF_FRECENCY_DB ?? undefined;
+  const historyDbPath = dm.getFlag("fff-history-db") ?? process.env.FFF_HISTORY_DB ?? undefined;
+  function resolveBoolOpt(flagName, envName) {
+    const flag = dm.getFlag(flagName);
+    if (typeof flag === "boolean")
+      return flag;
+    if (typeof flag === "string")
+      return flag === "true" || flag === "1";
+    const env = process.env[envName];
+    return env === "1" || env === "true";
+  }
+  const enableFsRootScanning = resolveBoolOpt("fff-enable-root-scan", "FFF_ENABLE_ROOT_SCAN");
+  function getMode() {
+    return currentMode;
+  }
+  function setMode(mode) {
+    currentMode = mode;
+  }
+  function shouldEnableMentions() {
+    return currentMode !== "tools-only";
+  }
+  function ensureFinder(cwd) {
+    if (finder && !finder.isDestroyed && finderCwd === cwd)
+      return Promise.resolve(finder);
+    if (finderPromise)
+      return finderPromise;
+    finderPromise = (async () => {
+      if (finder && !finder.isDestroyed) {
+        finder.destroy();
+        finder = null;
+        finderCwd = null;
+      }
+      const result = FileFinder.create({
+        basePath: cwd,
+        frecencyDbPath,
+        historyDbPath,
+        aiMode: true,
+        enableHomeDirScanning: true,
+        enableFsRootScanning
+      });
+      if (!result.ok)
+        throw new Error(`Failed to create FFF file finder: ${result.error}`);
+      finder = result.value;
+      finderCwd = cwd;
+      await finder.waitForScan(15000);
+      return finder;
+    })().finally(() => {
+      finderPromise = null;
+    });
+    return finderPromise;
+  }
+  function destroyFinder() {
+    if (finder && !finder.isDestroyed) {
+      finder.destroy();
+      finder = null;
+      finderCwd = null;
+    }
+  }
+  async function getMentionItems(query, signal) {
+    if (signal.aborted)
+      return [];
+    const f = await ensureFinder(activeCwd);
+    if (signal.aborted)
+      return [];
+    const result = f.mixedSearch(query, { pageSize: MENTION_MAX_RESULTS });
+    if (!result.ok)
+      return [];
+    return result.value.items.slice(0, MENTION_MAX_RESULTS).map((mixed) => {
+      if (mixed.type === "directory") {
+        return {
+          value: buildAtCompletionValue(mixed.item.relativePath),
+          label: mixed.item.dirName,
+          description: mixed.item.relativePath
+        };
+      }
+      return {
+        value: buildAtCompletionValue(mixed.item.relativePath),
+        label: mixed.item.fileName,
+        description: mixed.item.relativePath
+      };
+    });
+  }
+  function registerAutocompleteProvider(ctx) {
+    ctx.ui.addAutocompleteProvider((current) => {
+      const mentionProvider = createFffMentionProvider(getMentionItems);
+      return {
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+          if (shouldEnableMentions()) {
+            try {
+              const mentionResult = await mentionProvider.getSuggestions(lines, cursorLine, cursorCol, options);
+              if (mentionResult)
+                return mentionResult;
+            } catch {}
+          }
+          return current.getSuggestions(lines, cursorLine, cursorCol, options);
+        },
+        applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+          return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+        },
+        shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+          return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+        }
+      };
+    });
+  }
+  dm.registerFlag("fff-mode", {
+    description: "FFF mode: tools-and-ui | tools-only | override",
+    type: "string"
+  });
+  dm.registerFlag("fff-frecency-db", {
+    description: "Path to the frecency database (overrides FFF_FRECENCY_DB env)",
+    type: "string"
+  });
+  dm.registerFlag("fff-history-db", {
+    description: "Path to the query history database (overrides FFF_HISTORY_DB env)",
+    type: "string"
+  });
+  dm.registerFlag("fff-enable-root-scan", {
+    description: "Allow indexing when launched from the filesystem root (also: FFF_ENABLE_ROOT_SCAN env)",
+    type: "boolean"
+  });
+  dm.on("session_start", async (_event, ctx) => {
+    try {
+      activeCwd = ctx.cwd;
+      const entries = ctx.sessionManager?.getEntries();
+      if (entries) {
+        const modeEntry = [...entries].reverse().find((e) => e.type === "custom" && e.customType === "fff-mode");
+        if (modeEntry && typeof modeEntry.data?.mode === "string" && VALID_MODES.includes(modeEntry.data.mode)) {
+          const restored = modeEntry.data.mode;
+          if (restored !== currentMode) {
+            currentMode = restored;
+          }
+        }
+      }
+      registerAutocompleteProvider(ctx);
+      await ensureFinder(activeCwd);
+    } catch (e) {
+      ctx.ui.notify(`FFF init failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+    }
+  });
+  dm.on("session_shutdown", async () => {
+    destroyFinder();
+  });
+  const renderTextResult = (result, options, theme, context, maxLines = 15) => {
+    const text = context.lastComponent ?? new Text("", 0, 0);
+    const output = result.content?.find((c) => c.type === "text")?.text?.trim() ?? "";
+    if (!output) {
+      text.setText(theme.fg("muted", "No output"));
+      return text;
+    }
+    const lines = output.split(`
+`);
+    const displayLines = lines.slice(0, options.expanded ? lines.length : maxLines);
+    let content = `
+${displayLines.map((line) => theme.fg("toolOutput", line)).join(`
+`)}`;
+    if (lines.length > displayLines.length) {
+      content += theme.fg("muted", `
+... (${lines.length - displayLines.length} more lines)`);
+    }
+    text.setText(content);
+    return text;
+  };
+  const grepSchema = Type.Object({
+    pattern: Type.String({
+      description: "Search pattern (literal text or regex)"
+    }),
+    path: Type.Optional(Type.String({
+      description: "Repo-relative path constraint. Directory prefix (src/ or src/foo/), bare filename with extension (main.rs), or glob (*.ts, src/**/*.cc, {src,lib}/**). Applied to the full repo-relative path."
+    })),
+    exclude: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], {
+      description: "Exclude paths (comma/space-separated or array). Same syntax as path: directory prefix ('test/'), filename with extension ('config.json'), or glob ('*.min.js', '**/*.{rs,go}'). A leading '!' is optional and ignored — both 'test/' and '!test/' work. Example: 'test/,*.min.js,!vendor/'."
+    })),
+    caseSensitive: Type.Optional(Type.Boolean({
+      description: "Force case-sensitive matching. Default uses smart-case (case-insensitive when pattern is all lowercase)."
+    })),
+    context: Type.Optional(Type.Number({ description: "Context lines before+after each match" })),
+    limit: Type.Optional(Type.Number({
+      description: `Max matches (default ${DEFAULT_GREP_LIMIT})`
+    })),
+    cursor: Type.Optional(Type.String({ description: "Pagination cursor from previous result" }))
+  });
+  dm.registerTool({
+    name: toolNames.grep,
+    label: toolNames.grep,
+    description: `Grep file contents. Smart-case, auto-detects regex vs literal, git-aware. Results are ranked by frecency (most-accessed files first); matches within a file stay in source order. Default limit ${DEFAULT_GREP_LIMIT}.`,
+    promptSnippet: "Grep contents",
+    promptGuidelines: [
+      "Prefer bare identifiers as patterns. Literal queries are most efficient.",
+      "Use path for include ('src/', '*.ts') and exclude for noise ('test/,*.min.js').",
+      "caseSensitive: true when you need exact case (smart-case otherwise).",
+      "After 1-2 greps, read the top match instead of more greps."
+    ],
+    parameters: grepSchema,
+    async execute(_toolCallId, params, signal) {
+      if (signal?.aborted)
+        throw new Error("Operation aborted");
+      const f = await ensureFinder(activeCwd);
+      const effectiveLimit = Math.max(1, params.limit ?? DEFAULT_GREP_LIMIT);
+      const query = buildQuery(params.path, params.pattern, params.exclude, activeCwd);
+      const hasRegexSyntax = params.pattern !== params.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      let mode = hasRegexSyntax ? "regex" : "plain";
+      if (mode === "regex") {
+        try {
+          new RegExp(params.pattern);
+        } catch {
+          mode = "plain";
+        }
+      }
+      const p = params.pattern.trim();
+      const isWildcardOnly = hasRegexSyntax && /^(?:[.^$]*(?:[.][*+?]|\*|\+)[.^$]*|[.^$\s]*|\.\*\??|\.\*[+?]?|\.\+\??|\.|\*|\?)$/.test(p);
+      if (isWildcardOnly) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Pattern '${params.pattern}' matches everything — grep needs a concrete substring or identifier. Example: \`pattern: 'MyClass'\` or \`pattern: 'export function'\`.`
+            }
+          ],
+          details: { totalMatched: 0, totalFiles: 0 }
+        };
+      }
+      const smartCase = params.caseSensitive !== true;
+      const grepResult = f.grep(query, {
+        mode,
+        smartCase,
+        maxMatchesPerFile: Math.min(effectiveLimit, 50),
+        cursor: (params.cursor ? getCursor(params.cursor) : null) ?? null,
+        beforeContext: params.context ?? 0,
+        afterContext: params.context ?? 0,
+        classifyDefinitions: true
+      });
+      if (!grepResult.ok)
+        throw new Error(grepResult.error);
+      let result = grepResult.value;
+      let fuzzyNotice = null;
+      if (result.items.length === 0 && !params.cursor && mode !== "regex") {
+        const fuzzy = f.grep(params.pattern, {
+          mode: "fuzzy",
+          smartCase,
+          maxMatchesPerFile: Math.min(effectiveLimit, 50),
+          cursor: null,
+          beforeContext: 0,
+          afterContext: 0,
+          classifyDefinitions: true
+        });
+        if (fuzzy.ok && fuzzy.value.items.length > 0) {
+          fuzzyNotice = `0 exact matches. Maybe you meant this?`;
+          result = fuzzy.value;
+        }
+      }
+      let output = formatGrepOutput(result);
+      const notices = [];
+      if (result.regexFallbackError) {
+        notices.push(`Invalid regex: ${result.regexFallbackError}, used literal match`);
+      }
+      if (result.nextCursor) {
+        notices.push(`Continue with cursor="${storeCursor(result.nextCursor)}"`);
+      }
+      if (notices.length > 0)
+        output += `
 
-[${R.join(". ")}]`;if(v)N=`[${v}]
-${N}`;return{content:[{type:"text",text:N}],details:{totalMatched:D.totalMatched,totalFiles:D.totalFiles}}},renderCall(Y,j,K){let H=K.lastComponent??new L("",0,0),Q=Y?.pattern??"",X=Y?.path??".",U=j.fg("toolTitle",j.bold(V.grep))+" "+j.fg("accent",`/${Q}/`)+j.fg("toolOutput",` in ${X}`);if(Y?.limit!==void 0)U+=j.fg("toolOutput",` limit ${Y.limit}`);if(Y?.cursor)U+=j.fg("muted"," (page)");return H.setText(U),H},renderResult(Y,j,K,H){return g(Y,j,K,H,15)}});let jj=W.Object({pattern:W.String({description:"Fuzzy filename search and glob search. Frecency-ranked, git-aware. Multi-word = narrower (AND) not bound to order, use for multi word related concept search. Prefer this over ls/find/bash as the first exploration step whenever the user names a concept, feature, or symbol — it surfaces the relevant files in one call. Only use ls/read on a directory when you specifically need the alphabetical layout of an unknown repo, or when a concept search returned nothing."}),path:W.Optional(W.String({description:"Repo-relative path constraint. Directory prefix (src/ or src/foo/), bare filename with extension (main.rs), or glob (*.ts, src/**/*.cc, {src,lib}/**). Applied to the full repo-relative path."})),exclude:W.Optional(W.Union([W.String(),W.Array(W.String())],{description:"Exclude paths (comma/space-separated or array). Same syntax as path: directory prefix ('test/'), filename with extension ('config.json'), or glob ('*.min.js', '**/*.{rs,go}'). A leading '!' is optional and ignored — both 'test/' and '!test/' work. Example: 'test/,*.min.js,!vendor/'."})),limit:W.Optional(W.Number({description:`Max results per page (default ${f})`})),cursor:W.Optional(W.String({description:"Pagination cursor from previous result"}))});if(J.registerTool({name:V.find,label:V.find,description:`Fuzzy path search and glob search. Matches against the whole repo-relative path, not just the filename. Frecency-ranked, git-aware. Multi-word = narrower (AND). Default limit ${f}.`,promptSnippet:"Find files by path or glob",promptGuidelines:["Matches the WHOLE path, not just the filename — `profile` hits `chrome/browser/profiles/x.cc` too.","Keep queries to 1-2 terms; extra words narrow.","Use for paths, not content. Use grep for content.","For exact path matches use a glob in `path` — e.g. path: '**/profile.h' for exact filename, or path: 'src/**/profile.h' scoped to a subtree. Bare patterns are fuzzy.","To list everything inside a directory, pass path: 'dir/**' with an empty or wildcard pattern instead of using pattern alone.","Use exclude: 'test/,*.min.js' to cut noise in large repos."],parameters:jj,async execute(Y,j,K){if(K?.aborted)throw Error("Operation aborted");let H=await F(B),Q=j.cursor?kj(j.cursor):void 0,X=Q?Q.pageSize:Math.max(1,j.limit??f),U=Q?Q.query:x(j.path,j.pattern,j.exclude,B),q=Q?Q.pattern:j.pattern,b=Q?.nextPageIndex??0,S=H.fileSearch(U,{pageIndex:b,pageSize:X});if(!S.ok)throw Error(S.error);let O=S.value,A=bj(O,X,q),D=A.output,v=b*X+O.items.length,N=O.items.length>=X&&O.totalMatched>v,R=[];if(A.weak&&A.shownCount>0)R.push(`Query "${q}" produced only weak scattered fuzzy matches. Output capped at ${A.shownCount}/${O.totalMatched}.`);if(!A.weak&&N){let I=O.totalMatched-v,Jj=Xj({query:U,pattern:q,pageSize:X,nextPageIndex:b+1});R.push(`${I} more match${I===1?"":"es"} available. cursor="${Jj}" to continue`)}if(R.length>0)D+=`
+[${notices.join(". ")}]`;
+      if (fuzzyNotice)
+        output = `[${fuzzyNotice}]
+${output}`;
+      return {
+        content: [{ type: "text", text: output }],
+        details: {
+          totalMatched: result.totalMatched,
+          totalFiles: result.totalFiles
+        }
+      };
+    },
+    renderCall(args, theme, context) {
+      const text = context.lastComponent ?? new Text("", 0, 0);
+      const pattern = args?.pattern ?? "";
+      const path = args?.path ?? ".";
+      let content = theme.fg("toolTitle", theme.bold(toolNames.grep)) + " " + theme.fg("accent", `/${pattern}/`) + theme.fg("toolOutput", ` in ${path}`);
+      if (args?.limit !== undefined)
+        content += theme.fg("toolOutput", ` limit ${args.limit}`);
+      if (args?.cursor)
+        content += theme.fg("muted", ` (page)`);
+      text.setText(content);
+      return text;
+    },
+    renderResult(result, options, theme, context) {
+      return renderTextResult(result, options, theme, context, 15);
+    }
+  });
+  const findSchema = Type.Object({
+    pattern: Type.String({
+      description: "Fuzzy filename search and glob search. Frecency-ranked, git-aware. Multi-word = narrower (AND) not bound to order, use for multi word related concept search. Prefer this over ls/find/bash as the first exploration step whenever the user names a concept, feature, or symbol — it surfaces the relevant files in one call. Only use ls/read on a directory when you specifically need the alphabetical layout of an unknown repo, or when a concept search returned nothing."
+    }),
+    path: Type.Optional(Type.String({
+      description: "Repo-relative path constraint. Directory prefix (src/ or src/foo/), bare filename with extension (main.rs), or glob (*.ts, src/**/*.cc, {src,lib}/**). Applied to the full repo-relative path."
+    })),
+    exclude: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], {
+      description: "Exclude paths (comma/space-separated or array). Same syntax as path: directory prefix ('test/'), filename with extension ('config.json'), or glob ('*.min.js', '**/*.{rs,go}'). A leading '!' is optional and ignored — both 'test/' and '!test/' work. Example: 'test/,*.min.js,!vendor/'."
+    })),
+    limit: Type.Optional(Type.Number({
+      description: `Max results per page (default ${DEFAULT_FIND_LIMIT})`
+    })),
+    cursor: Type.Optional(Type.String({ description: "Pagination cursor from previous result" }))
+  });
+  dm.registerTool({
+    name: toolNames.find,
+    label: toolNames.find,
+    description: `Fuzzy path search and glob search. Matches against the whole repo-relative path, not just the filename. Frecency-ranked, git-aware. Multi-word = narrower (AND). Default limit ${DEFAULT_FIND_LIMIT}.`,
+    promptSnippet: "Find files by path or glob",
+    promptGuidelines: [
+      "Matches the WHOLE path, not just the filename — `profile` hits `chrome/browser/profiles/x.cc` too.",
+      "Keep queries to 1-2 terms; extra words narrow.",
+      "Use for paths, not content. Use grep for content.",
+      "For exact path matches use a glob in `path` — e.g. path: '**/profile.h' for exact filename, or path: 'src/**/profile.h' scoped to a subtree. Bare patterns are fuzzy.",
+      "To list everything inside a directory, pass path: 'dir/**' with an empty or wildcard pattern instead of using pattern alone.",
+      "Use exclude: 'test/,*.min.js' to cut noise in large repos."
+    ],
+    parameters: findSchema,
+    async execute(_toolCallId, params, signal) {
+      if (signal?.aborted)
+        throw new Error("Operation aborted");
+      const f = await ensureFinder(activeCwd);
+      const resumed = params.cursor ? getFindCursor(params.cursor) : undefined;
+      const effectiveLimit = resumed ? resumed.pageSize : Math.max(1, params.limit ?? DEFAULT_FIND_LIMIT);
+      const query = resumed ? resumed.query : buildQuery(params.path, params.pattern, params.exclude, activeCwd);
+      const pattern = resumed ? resumed.pattern : params.pattern;
+      const pageIndex = resumed?.nextPageIndex ?? 0;
+      const searchResult = f.fileSearch(query, {
+        pageIndex,
+        pageSize: effectiveLimit
+      });
+      if (!searchResult.ok)
+        throw new Error(searchResult.error);
+      const result = searchResult.value;
+      const formatted = formatFindOutput(result, effectiveLimit, pattern);
+      let output = formatted.output;
+      const shownSoFar = pageIndex * effectiveLimit + result.items.length;
+      const hasMore = result.items.length >= effectiveLimit && result.totalMatched > shownSoFar;
+      const notices = [];
+      if (formatted.weak && formatted.shownCount > 0)
+        notices.push(`Query "${pattern}" produced only weak scattered fuzzy matches. Output capped at ${formatted.shownCount}/${result.totalMatched}.`);
+      if (!formatted.weak && hasMore) {
+        const remaining = result.totalMatched - shownSoFar;
+        const cursorId = storeFindCursor({
+          query,
+          pattern,
+          pageSize: effectiveLimit,
+          nextPageIndex: pageIndex + 1
+        });
+        notices.push(`${remaining} more match${remaining === 1 ? "" : "es"} available. cursor="${cursorId}" to continue`);
+      }
+      if (notices.length > 0)
+        output += `
 
-[${R.join(". ")}]`;return{content:[{type:"text",text:D}],details:{totalMatched:O.totalMatched,totalFiles:O.totalFiles,pageIndex:b,hasMore:N}}},renderCall(Y,j,K){let H=K.lastComponent??new L("",0,0),Q=Y?.pattern??"",X=Y?.path??".",U=j.fg("toolTitle",j.bold(V.find))+" "+j.fg("accent",Q)+j.fg("toolOutput",` in ${X}`);if(Y?.limit!==void 0)U+=j.fg("toolOutput",` (limit ${Y.limit})`);if(Y?.cursor)U+=j.fg("muted"," (page)");return H.setText(U),H},renderResult(Y,j,K,H){return g(Y,j,K,H,20)}}),process.env.DM_FFF_MULTIGREP==="1"){let Y=W.Object({patterns:W.Array(W.String(),{description:"Literal patterns (OR). Include snake_case/camelCase/PascalCase variants."}),constraints:W.Optional(W.String({description:"File filter, e.g. '*.{ts,tsx} !test/'"})),context:W.Optional(W.Number({description:"Context lines before+after"})),limit:W.Optional(W.Number({description:`Max matches (default ${E})`})),cursor:W.Optional(W.String({description:"Pagination cursor"}))});J.registerTool({name:V.multiGrep,label:V.multiGrep,description:"Search file contents for ANY of multiple literal patterns (OR, SIMD Aho-Corasick). Faster than regex alternation.",promptSnippet:"Multi-pattern OR content search",promptGuidelines:["Use when searching for several identifiers at once.","Include all naming-convention variants (snake/camel/Pascal).","Patterns are literal. Use constraints for file filters."],parameters:Y,async execute(j,K,H){if(H?.aborted)throw Error("Operation aborted");if(!K.patterns?.length)throw Error("patterns array must have at least 1 element");let Q=await F(B),X=Math.max(1,K.limit??E),U=Q.multiGrep({patterns:K.patterns,constraints:K.constraints,maxMatchesPerFile:Math.min(X,50),smartCase:!0,cursor:(K.cursor?d(K.cursor):null)??null,beforeContext:K.context??0,afterContext:K.context??0});if(!U.ok)throw Error(U.error);let q=U.value,b=o(q),S=[];if(q.items.length>=X)S.push(`${X}+ matches (refine patterns)`);if(q.nextCursor)S.push(`More available. cursor="${u(q.nextCursor)}" to continue`);if(S.length>0)b+=`
+[${notices.join(". ")}]`;
+      return {
+        content: [{ type: "text", text: output }],
+        details: {
+          totalMatched: result.totalMatched,
+          totalFiles: result.totalFiles,
+          pageIndex,
+          hasMore
+        }
+      };
+    },
+    renderCall(args, theme, context) {
+      const text = context.lastComponent ?? new Text("", 0, 0);
+      const pattern = args?.pattern ?? "";
+      const path = args?.path ?? ".";
+      let content = theme.fg("toolTitle", theme.bold(toolNames.find)) + " " + theme.fg("accent", pattern) + theme.fg("toolOutput", ` in ${path}`);
+      if (args?.limit !== undefined)
+        content += theme.fg("toolOutput", ` (limit ${args.limit})`);
+      if (args?.cursor)
+        content += theme.fg("muted", ` (page)`);
+      text.setText(content);
+      return text;
+    },
+    renderResult(result, options, theme, context) {
+      return renderTextResult(result, options, theme, context, 20);
+    }
+  });
+  const enableMultiGrep = process.env.DM_FFF_MULTIGREP === "1";
+  if (enableMultiGrep) {
+    const multiGrepSchema = Type.Object({
+      patterns: Type.Array(Type.String(), {
+        description: "Literal patterns (OR). Include snake_case/camelCase/PascalCase variants."
+      }),
+      constraints: Type.Optional(Type.String({ description: "File filter, e.g. '*.{ts,tsx} !test/'" })),
+      context: Type.Optional(Type.Number({ description: "Context lines before+after" })),
+      limit: Type.Optional(Type.Number({
+        description: `Max matches (default ${DEFAULT_GREP_LIMIT})`
+      })),
+      cursor: Type.Optional(Type.String({ description: "Pagination cursor" }))
+    });
+    dm.registerTool({
+      name: toolNames.multiGrep,
+      label: toolNames.multiGrep,
+      description: "Search file contents for ANY of multiple literal patterns (OR, SIMD Aho-Corasick). Faster than regex alternation.",
+      promptSnippet: "Multi-pattern OR content search",
+      promptGuidelines: [
+        "Use when searching for several identifiers at once.",
+        "Include all naming-convention variants (snake/camel/Pascal).",
+        "Patterns are literal. Use constraints for file filters."
+      ],
+      parameters: multiGrepSchema,
+      async execute(_toolCallId, params, signal) {
+        if (signal?.aborted)
+          throw new Error("Operation aborted");
+        if (!params.patterns?.length)
+          throw new Error("patterns array must have at least 1 element");
+        const f = await ensureFinder(activeCwd);
+        const effectiveLimit = Math.max(1, params.limit ?? DEFAULT_GREP_LIMIT);
+        const grepResult = f.multiGrep({
+          patterns: params.patterns,
+          constraints: params.constraints,
+          maxMatchesPerFile: Math.min(effectiveLimit, 50),
+          smartCase: true,
+          cursor: (params.cursor ? getCursor(params.cursor) : null) ?? null,
+          beforeContext: params.context ?? 0,
+          afterContext: params.context ?? 0
+        });
+        if (!grepResult.ok)
+          throw new Error(grepResult.error);
+        const result = grepResult.value;
+        let output = formatGrepOutput(result);
+        const notices = [];
+        if (result.items.length >= effectiveLimit)
+          notices.push(`${effectiveLimit}+ matches (refine patterns)`);
+        if (result.nextCursor)
+          notices.push(`More available. cursor="${storeCursor(result.nextCursor)}" to continue`);
+        if (notices.length > 0)
+          output += `
 
-[${S.join(". ")}]`;return{content:[{type:"text",text:b}],details:{totalMatched:q.totalMatched,totalFiles:q.totalFiles,patterns:K.patterns}}},renderCall(j,K,H){let Q=H.lastComponent??new L("",0,0),X=j?.patterns??[],U=j?.constraints,q=K.fg("toolTitle",K.bold(V.multiGrep))+" "+K.fg("accent",X.map((b)=>`"${b}"`).join(", "));if(U)q+=K.fg("toolOutput",` (${U})`);if(j?.cursor)q+=K.fg("muted"," (page)");return Q.setText(q),Q},renderResult(j,K,H,Q){return g(j,K,H,Q,15)}})}J.registerCommand("fff-mode",{description:"Show or set FFF mode: /fff-mode [tools-and-ui | tools-only | override]",handler:async(Y,j)=>{let K=(Y||"").trim();if(!K){let U=T(),q=J.getFlag("fff-mode")??"unset";j.ui.notify(`Current mode: '${U}' (flag: ${q})`,"info");return}if(!h.includes(K)){j.ui.notify(`Usage: /fff-mode [${h.join(" | ")}]`,"warning");return}let H=K,Q=T();a(H),J.appendEntry("fff-mode",{mode:H});let X=Q==="override"!==(H==="override")?" (tool name change requires /reload)":"";j.ui.notify(`Mode changed: '${Q}' → '${H}'${X}`,"info")}}),J.registerCommand("fff-health",{description:"Show FFF file finder health and status",handler:async(Y,j)=>{if(!$||$.isDestroyed){j.ui.notify("FFF not initialized","warning");return}let K=$.healthCheck();if(!K.ok){j.ui.notify(`Health check failed: ${K.error}`,"error");return}let H=K.value,Q=[`FFF v${H.version}`,`Mode: ${T()}`,`Git: ${H.git.repositoryFound?`yes (${H.git.workdir??"unknown"})`:"no"}`,`Picker: ${H.filePicker.initialized?`${H.filePicker.indexedFiles??0} files`:"not initialized"}`,`Frecency: ${H.frecency.initialized?"active":"disabled"}`,`Query tracker: ${H.queryTracker.initialized?"active":"disabled"}`],X=$.getScanProgress();if(X.ok)Q.push(`Scanning: ${X.value.isScanning?"yes":"no"} (${X.value.scannedFilesCount} files)`);j.ui.notify(Q.join(`
-`),"info")}}),J.registerCommand("fff-rescan",{description:"Trigger FFF to rescan files",handler:async(Y,j)=>{if(!$||$.isDestroyed){j.ui.notify("FFF not initialized","warning");return}let K=$.scanFiles();if(!K.ok){j.ui.notify(`Rescan failed: ${K.error}`,"error");return}j.ui.notify("FFF rescan triggered","info")}})}export{n as fffFileAnnotation,Pj as default};
+[${notices.join(". ")}]`;
+        return {
+          content: [{ type: "text", text: output }],
+          details: {
+            totalMatched: result.totalMatched,
+            totalFiles: result.totalFiles,
+            patterns: params.patterns
+          }
+        };
+      },
+      renderCall(args, theme, context) {
+        const text = context.lastComponent ?? new Text("", 0, 0);
+        const patterns = args?.patterns ?? [];
+        const constraints = args?.constraints;
+        let content = theme.fg("toolTitle", theme.bold(toolNames.multiGrep)) + " " + theme.fg("accent", patterns.map((p) => `"${p}"`).join(", "));
+        if (constraints)
+          content += theme.fg("toolOutput", ` (${constraints})`);
+        if (args?.cursor)
+          content += theme.fg("muted", ` (page)`);
+        text.setText(content);
+        return text;
+      },
+      renderResult(result, options, theme, context) {
+        return renderTextResult(result, options, theme, context, 15);
+      }
+    });
+  }
+  dm.registerCommand("fff-mode", {
+    description: "Show or set FFF mode: /fff-mode [tools-and-ui | tools-only | override]",
+    handler: async (args, ctx) => {
+      const arg = (args || "").trim();
+      if (!arg) {
+        const mode = getMode();
+        const flag = dm.getFlag("fff-mode") ?? "unset";
+        ctx.ui.notify(`Current mode: '${mode}' (flag: ${flag})`, "info");
+        return;
+      }
+      if (!VALID_MODES.includes(arg)) {
+        ctx.ui.notify(`Usage: /fff-mode [${VALID_MODES.join(" | ")}]`, "warning");
+        return;
+      }
+      const newMode = arg;
+      const oldMode = getMode();
+      setMode(newMode);
+      dm.appendEntry("fff-mode", { mode: newMode });
+      const note = oldMode === "override" !== (newMode === "override") ? " (tool name change requires /reload)" : "";
+      ctx.ui.notify(`Mode changed: '${oldMode}' → '${newMode}'${note}`, "info");
+    }
+  });
+  dm.registerCommand("fff-health", {
+    description: "Show FFF file finder health and status",
+    handler: async (_args, ctx) => {
+      if (!finder || finder.isDestroyed) {
+        ctx.ui.notify("FFF not initialized", "warning");
+        return;
+      }
+      const health = finder.healthCheck();
+      if (!health.ok) {
+        ctx.ui.notify(`Health check failed: ${health.error}`, "error");
+        return;
+      }
+      const h = health.value;
+      const lines = [
+        `FFF v${h.version}`,
+        `Mode: ${getMode()}`,
+        `Git: ${h.git.repositoryFound ? `yes (${h.git.workdir ?? "unknown"})` : "no"}`,
+        `Picker: ${h.filePicker.initialized ? `${h.filePicker.indexedFiles ?? 0} files` : "not initialized"}`,
+        `Frecency: ${h.frecency.initialized ? "active" : "disabled"}`,
+        `Query tracker: ${h.queryTracker.initialized ? "active" : "disabled"}`
+      ];
+      const progress = finder.getScanProgress();
+      if (progress.ok) {
+        lines.push(`Scanning: ${progress.value.isScanning ? "yes" : "no"} (${progress.value.scannedFilesCount} files)`);
+      }
+      ctx.ui.notify(lines.join(`
+`), "info");
+    }
+  });
+  dm.registerCommand("fff-rescan", {
+    description: "Trigger FFF to rescan files",
+    handler: async (_args, ctx) => {
+      if (!finder || finder.isDestroyed) {
+        ctx.ui.notify("FFF not initialized", "warning");
+        return;
+      }
+      const result = finder.scanFiles();
+      if (!result.ok) {
+        ctx.ui.notify(`Rescan failed: ${result.error}`, "error");
+        return;
+      }
+      ctx.ui.notify("FFF rescan triggered", "info");
+    }
+  });
+}