@vpxa/kb 0.1.1 → 0.1.3

package/packages/server/dist/tools/toolkit.tools.js

@@ -1,1674 +1,21 @@
-import {
-  addToWorkset,
-  batch,
-  check,
-  checkpointLatest,
-  checkpointList,
-  checkpointLoad,
-  checkpointSave,
-  codemod,
-  compact,
-  dataTransform,
-  delegate,
-  delegateListModels,
-  deleteWorkset,
-  diffParse,
-  evaluate,
-  fileSummary,
-  find,
-  findDeadSymbols,
-  findExamples,
-  getWorkset,
-  gitContext,
-  health,
-  laneCreate,
-  laneDiff,
-  laneDiscard,
-  laneList,
-  laneMerge,
-  laneStatus,
-  listWorksets,
-  parseOutput,
-  processList,
-  processLogs,
-  processStart,
-  processStatus,
-  processStop,
-  queueClear,
-  queueCreate,
-  queueDelete,
-  queueDone,
-  queueFail,
-  queueGet,
-  queueList,
-  queueNext,
-  queuePush,
-  removeFromWorkset,
-  rename,
-  saveWorkset,
-  scopeMap,
-  stashClear,
-  stashDelete,
-  stashGet,
-  stashList,
-  stashSet,
-  symbol,
-  testRun,
-  trace,
-  watchList,
-  watchStart,
-  watchStop,
-  webFetch
-} from "@kb/tools";
-import { z } from "zod";
-function registerCompactTool(server, embedder) {
-  server.registerTool(
-    "compact",
-    {
-      description: "Compress text to relevant sections using embedding similarity (no LLM). Ideal for reducing file contents before context injection. Segments by paragraph/sentence/line.",
-      inputSchema: {
-        text: z.string().describe("The text to compress"),
-        query: z.string().describe("Focus query \u2014 what are you trying to understand?"),
-        max_chars: z.number().min(100).max(5e4).default(3e3).describe("Target output size in characters"),
-        segmentation: z.enum(["paragraph", "sentence", "line"]).default("paragraph").describe("How to split the text for scoring")
-      }
-    },
-    async ({ text, query, max_chars, segmentation }) => {
-      try {
-        const result = await compact(embedder, {
-          text,
-          query,
-          maxChars: max_chars,
-          segmentation
-        });
-        const summary = [
-          `Compressed ${result.originalChars} \u2192 ${result.compressedChars} chars (${(result.ratio * 100).toFixed(0)}%)`,
-          `Kept ${result.segmentsKept}/${result.segmentsTotal} segments`,
-          "",
-          result.text
-        ].join("\n");
-        return {
-          content: [{ type: "text", text: summary }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Compact failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerScopeMapTool(server, embedder, store) {
-  server.registerTool(
-    "scope_map",
-    {
-      description: "Generate a task-scoped reading plan. Given a task description, identifies which files and sections are relevant, with estimated token counts and suggested reading order.",
-      inputSchema: {
-        task: z.string().describe("Description of the task to scope"),
-        max_files: z.number().min(1).max(50).default(15).describe("Maximum files to include"),
-        content_type: z.string().optional().describe("Filter by content type")
-      }
-    },
-    async ({ task, max_files, content_type }) => {
-      try {
-        const result = await scopeMap(embedder, store, {
-          task,
-          maxFiles: max_files,
-          contentType: content_type
-        });
-        const lines = [
-          `## Scope Map: ${task}`,
-          `Total estimated tokens: ~${result.totalEstimatedTokens}`,
-          "",
-          "### Files (by relevance)",
-          ...result.files.map(
-            (f, i) => `${i + 1}. **${f.path}** (~${f.estimatedTokens} tokens, ${(f.relevance * 100).toFixed(0)}% relevant)
-   ${f.reason}
-   Focus: ${f.focusRanges.map((r) => `L${r.start}-${r.end}`).join(", ")}`
-          ),
-          "",
-          "### Suggested Reading Order",
-          ...result.readingOrder.map((p, i) => `${i + 1}. ${p}`)
-        ];
-        return {
-          content: [
-            {
-              type: "text",
-              text: lines.join("\n") + "\n\n---\n_Next: Use `search` to dive into specific files, or `compact` to compress file contents for context._"
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Scope map failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerFindTool(server, embedder, store) {
-  server.registerTool(
-    "find",
-    {
-      description: "Federated search across vector similarity, keyword (FTS), file glob, and regex pattern. Combines strategies, deduplicates, and returns unified results.",
-      inputSchema: {
-        query: z.string().optional().describe("Semantic/keyword search query"),
-        glob: z.string().optional().describe("File glob pattern"),
-        pattern: z.string().optional().describe("Regex pattern to match in content"),
-        limit: z.number().min(1).max(50).default(10).describe("Max results"),
-        content_type: z.string().optional().describe("Filter by content type")
-      }
-    },
-    async ({ query, glob, pattern, limit, content_type }) => {
-      try {
-        const result = await find(embedder, store, {
-          query,
-          glob,
-          pattern,
-          limit,
-          contentType: content_type
-        });
-        if (result.results.length === 0) {
-          return {
-            content: [{ type: "text", text: "No results found." }]
-          };
-        }
-        const lines = [
-          `Found ${result.totalFound} results via ${result.strategies.join(" + ")}`,
-          "",
-          ...result.results.map((r) => {
-            const loc = r.lineRange ? `:${r.lineRange.start}-${r.lineRange.end}` : "";
-            const preview = r.preview ? `
-   ${r.preview.slice(0, 100)}...` : "";
-            return `- [${r.source}] ${r.path}${loc} (${(r.score * 100).toFixed(0)}%)${preview}`;
-          })
-        ];
-        return {
-          content: [{ type: "text", text: lines.join("\n") }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Find failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerParseOutputTool(server) {
-  server.registerTool(
-    "parse_output",
-    {
-      description: "Parse structured data from build tool output. Supports tsc, vitest, biome, and git status. Auto-detects the tool or specify explicitly.",
-      inputSchema: {
-        output: z.string().describe("Raw output text from a build tool"),
-        tool: z.enum(["tsc", "vitest", "biome", "git-status"]).optional().describe("Tool to parse as (auto-detects if omitted)")
-      }
-    },
-    async ({ output, tool }) => {
-      try {
-        const normalizedOutput = output.replace(/\\n/g, "\n").replace(/\\t/g, "	");
-        const result = parseOutput(normalizedOutput, tool);
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Parse failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerWorksetTool(server) {
-  server.registerTool(
-    "workset",
-    {
-      description: "Manage named file sets (worksets). Save, load, list, add/remove files. Worksets persist across sessions in .kb-state/worksets.json.",
-      inputSchema: {
-        action: z.enum(["save", "get", "list", "delete", "add", "remove"]).describe("Operation to perform"),
-        name: z.string().optional().describe("Workset name (required for all except list)"),
-        files: z.array(z.string()).optional().describe("File paths (required for save, add, remove)"),
-        description: z.string().optional().describe("Description (for save)")
-      }
-    },
-    async ({ action, name, files, description }) => {
-      try {
-        switch (action) {
-          case "save": {
-            if (!name || !files) throw new Error("name and files required for save");
-            const ws = saveWorkset(name, files, { description });
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Saved workset "${ws.name}" with ${ws.files.length} files.`
-                }
-              ]
-            };
-          }
-          case "get": {
-            if (!name) throw new Error("name required for get");
-            const ws = getWorkset(name);
-            if (!ws)
-              return { content: [{ type: "text", text: `Workset "${name}" not found.` }] };
-            return {
-              content: [{ type: "text", text: JSON.stringify(ws, null, 2) }]
-            };
-          }
-          case "list": {
-            const all = listWorksets();
-            if (all.length === 0)
-              return { content: [{ type: "text", text: "No worksets." }] };
-            const text = all.map(
-              (w) => `- **${w.name}** (${w.files.length} files) \u2014 ${w.description ?? "no description"}`
-            ).join("\n");
-            return { content: [{ type: "text", text }] };
-          }
-          case "delete": {
-            if (!name) throw new Error("name required for delete");
-            const deleted = deleteWorkset(name);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: deleted ? `Deleted workset "${name}".` : `Workset "${name}" not found.`
-                }
-              ]
-            };
-          }
-          case "add": {
-            if (!name || !files) throw new Error("name and files required for add");
-            const ws = addToWorkset(name, files);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Added to workset "${ws.name}": now ${ws.files.length} files.`
-                }
-              ]
-            };
-          }
-          case "remove": {
-            if (!name || !files) throw new Error("name and files required for remove");
-            const ws = removeFromWorkset(name, files);
-            if (!ws)
-              return { content: [{ type: "text", text: `Workset "${name}" not found.` }] };
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Removed from workset "${ws.name}": now ${ws.files.length} files.`
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Workset operation failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerCheckTool(server) {
-  server.registerTool(
-    "check",
-    {
-      description: "Run incremental typecheck (tsc) and lint (biome) on the project or specific files. Returns structured error and warning lists.",
-      inputSchema: {
-        files: z.array(z.string()).optional().describe("Specific files to check (if omitted, checks all)"),
-        cwd: z.string().optional().describe("Working directory"),
-        skip_types: z.boolean().default(false).describe("Skip TypeScript typecheck"),
-        skip_lint: z.boolean().default(false).describe("Skip Biome lint")
-      }
-    },
-    async ({ files, cwd, skip_types, skip_lint }) => {
-      try {
-        const result = await check({
-          files,
-          cwd,
-          skipTypes: skip_types,
-          skipLint: skip_lint
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Check failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerBatchTool(server, embedder, store) {
-  server.registerTool(
-    "batch",
-    {
-      description: "Execute multiple built-in operations in parallel with concurrency control. Supported operation types: search, find, and check.",
-      inputSchema: {
-        operations: z.array(
-          z.object({
-            id: z.string().describe("Unique ID for this operation"),
-            type: z.enum(["search", "find", "check"]).describe("Built-in operation type"),
-            args: z.record(z.string(), z.unknown()).describe("Arguments for the operation")
-          })
-        ).min(1).describe("Operations to execute"),
-        concurrency: z.number().min(1).max(20).default(4).describe("Max concurrent operations")
-      }
-    },
-    async ({ operations, concurrency }) => {
-      try {
-        const result = await batch(
-          operations,
-          async (operation) => executeToolkitBatchOperation(operation, embedder, store),
-          { concurrency }
-        );
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Batch failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerSymbolTool(server, embedder, store) {
-  server.registerTool(
-    "symbol",
-    {
-      description: "Resolve a symbol: find where it is defined, who imports it, and where it is referenced. Works on TypeScript and JavaScript codebases.",
-      inputSchema: {
-        name: z.string().describe("Symbol name to look up (function, class, type, etc.)"),
-        limit: z.number().min(1).max(50).default(20).describe("Max results per category")
-      }
-    },
-    async ({ name, limit }) => {
-      try {
-        const result = await symbol(embedder, store, { name, limit });
-        return {
-          content: [{ type: "text", text: formatSymbolInfo(result) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Symbol lookup failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerEvalTool(server) {
-  server.registerTool(
-    "eval",
-    {
-      description: "Execute a JavaScript or TypeScript snippet in a constrained VM sandbox with a timeout. Captures console output and returned values.",
-      inputSchema: {
-        code: z.string().describe("Code snippet to execute"),
-        lang: z.enum(["js", "ts"]).default("js").optional().describe("Language mode: js executes directly, ts strips common type syntax first"),
-        timeout: z.number().min(1).max(6e4).default(5e3).optional().describe("Execution timeout in milliseconds")
-      }
-    },
-    async ({ code, lang, timeout }) => {
-      try {
-        const result = evaluate({ code, lang, timeout });
-        if (!result.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Eval failed in ${result.durationMs}ms: ${result.error ?? "Unknown error"}`
-              }
-            ],
-            isError: true
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Eval succeeded in ${result.durationMs}ms
+import{addToWorkset as x,batch as b,check as m,checkpointLatest as w,checkpointList as S,checkpointLoad as $,checkpointSave as k,codemod as E,compact as v,dataTransform as T,delegate as q,delegateListModels as O,deleteWorkset as M,diffParse as N,evaluate as _,fileSummary as R,find as g,findDeadSymbols as I,findExamples as J,getWorkset as C,gitContext as j,health as L,laneCreate as F,laneDiff as D,laneDiscard as A,laneList as P,laneMerge as W,laneStatus as K,listWorksets as U,parseOutput as B,processList as z,processLogs as G,processStart as Q,processStatus as H,processStop as V,queueClear as X,queueCreate as Y,queueDelete as Z,queueDone as ee,queueFail as te,queueGet as re,queueList as ne,queueNext as oe,queuePush as se,removeFromWorkset as ie,rename as ae,saveWorkset as ce,scopeMap as le,stashClear as de,stashDelete as ue,stashGet as pe,stashList as fe,stashSet as me,symbol as ge,testRun as he,trace as ye,watchList as xe,watchStart as be,watchStop as we,webFetch as Se}from"../../../tools/dist/index.js";import{z as r}from"zod";function Le(t,n){t.registerTool("compact",{description:"Compress text to relevant sections using embedding similarity (no LLM). Ideal for reducing file contents before context injection. Segments by paragraph/sentence/line.",inputSchema:{text:r.string().describe("The text to compress"),query:r.string().describe("Focus query \u2014 what are you trying to understand?"),max_chars:r.number().min(100).max(5e4).default(3e3).describe("Target output size in characters"),segmentation:r.enum(["paragraph","sentence","line"]).default("paragraph").describe("How to split the text for scoring")}},async({text:e,query:s,max_chars:o,segmentation:i})=>{try{const a=await v(n,{text:e,query:s,maxChars:o,segmentation:i});return{content:[{type:"text",text:[`Compressed ${a.originalChars} \u2192 ${a.compressedChars} chars (${(a.ratio*100).toFixed(0)}%)`,`Kept ${a.segmentsKept}/${a.segmentsTotal} segments`,"",a.text].join(`
+`)}]}}catch(a){return{content:[{type:"text",text:`Compact failed: ${a.message}`}],isError:!0}}})}function Fe(t,n,e){t.registerTool("scope_map",{description:"Generate a task-scoped reading plan. Given a task description, identifies which files and sections are relevant, with estimated token counts and suggested reading order.",inputSchema:{task:r.string().describe("Description of the task to scope"),max_files:r.number().min(1).max(50).default(15).describe("Maximum files to include"),content_type:r.string().optional().describe("Filter by content type")}},async({task:s,max_files:o,content_type:i})=>{try{const a=await le(n,e,{task:s,maxFiles:o,contentType:i});return{content:[{type:"text",text:[`## Scope Map: ${s}`,`Total estimated tokens: ~${a.totalEstimatedTokens}`,"","### Files (by relevance)",...a.files.map((c,u)=>`${u+1}. **${c.path}** (~${c.estimatedTokens} tokens, ${(c.relevance*100).toFixed(0)}% relevant)
+   ${c.reason}
+   Focus: ${c.focusRanges.map(d=>`L${d.start}-${d.end}`).join(", ")}`),"","### Suggested Reading Order",...a.readingOrder.map((c,u)=>`${u+1}. ${c}`)].join(`
+`)+"\n\n---\n_Next: Use `search` to dive into specific files, or `compact` to compress file contents for context._"}]}}catch(a){return{content:[{type:"text",text:`Scope map failed: ${a.message}`}],isError:!0}}})}function De(t,n,e){t.registerTool("find",{description:"Federated search across vector similarity, keyword (FTS), file glob, and regex pattern. Combines strategies, deduplicates, and returns unified results.",inputSchema:{query:r.string().optional().describe("Semantic/keyword search query"),glob:r.string().optional().describe("File glob pattern"),pattern:r.string().optional().describe("Regex pattern to match in content"),limit:r.number().min(1).max(50).default(10).describe("Max results"),content_type:r.string().optional().describe("Filter by content type")}},async({query:s,glob:o,pattern:i,limit:a,content_type:l})=>{try{const c=await g(n,e,{query:s,glob:o,pattern:i,limit:a,contentType:l});return c.results.length===0?{content:[{type:"text",text:"No results found."}]}:{content:[{type:"text",text:[`Found ${c.totalFound} results via ${c.strategies.join(" + ")}`,"",...c.results.map(d=>{const h=d.lineRange?`:${d.lineRange.start}-${d.lineRange.end}`:"",y=d.preview?`
+   ${d.preview.slice(0,100)}...`:"";return`- [${d.source}] ${d.path}${h} (${(d.score*100).toFixed(0)}%)${y}`})].join(`
+`)}]}}catch(c){return{content:[{type:"text",text:`Find failed: ${c.message}`}],isError:!0}}})}function Ae(t){t.registerTool("parse_output",{description:"Parse structured data from build tool output. Supports tsc, vitest, biome, and git status. Auto-detects the tool or specify explicitly.",inputSchema:{output:r.string().describe("Raw output text from a build tool"),tool:r.enum(["tsc","vitest","biome","git-status"]).optional().describe("Tool to parse as (auto-detects if omitted)")}},async({output:n,tool:e})=>{try{const s=n.replace(/\\n/g,`
+`).replace(/\\t/g,"	"),o=B(s,e);return{content:[{type:"text",text:JSON.stringify(o,null,2)}]}}catch(s){return{content:[{type:"text",text:`Parse failed: ${s.message}`}],isError:!0}}})}function Pe(t){t.registerTool("workset",{description:"Manage named file sets (worksets). Save, load, list, add/remove files. Worksets persist across sessions in .kb-state/worksets.json.",inputSchema:{action:r.enum(["save","get","list","delete","add","remove"]).describe("Operation to perform"),name:r.string().optional().describe("Workset name (required for all except list)"),files:r.array(r.string()).optional().describe("File paths (required for save, add, remove)"),description:r.string().optional().describe("Description (for save)")}},async({action:n,name:e,files:s,description:o})=>{try{switch(n){case"save":{if(!e||!s)throw new Error("name and files required for save");const i=ce(e,s,{description:o});return{content:[{type:"text",text:`Saved workset "${i.name}" with ${i.files.length} files.`}]}}case"get":{if(!e)throw new Error("name required for get");const i=C(e);return i?{content:[{type:"text",text:JSON.stringify(i,null,2)}]}:{content:[{type:"text",text:`Workset "${e}" not found.`}]}}case"list":{const i=U();return i.length===0?{content:[{type:"text",text:"No worksets."}]}:{content:[{type:"text",text:i.map(l=>`- **${l.name}** (${l.files.length} files) \u2014 ${l.description??"no description"}`).join(`
+`)}]}}case"delete":{if(!e)throw new Error("name required for delete");return{content:[{type:"text",text:M(e)?`Deleted workset "${e}".`:`Workset "${e}" not found.`}]}}case"add":{if(!e||!s)throw new Error("name and files required for add");const i=x(e,s);return{content:[{type:"text",text:`Added to workset "${i.name}": now ${i.files.length} files.`}]}}case"remove":{if(!e||!s)throw new Error("name and files required for remove");const i=ie(e,s);return i?{content:[{type:"text",text:`Removed from workset "${i.name}": now ${i.files.length} files.`}]}:{content:[{type:"text",text:`Workset "${e}" not found.`}]}}}}catch(i){return{content:[{type:"text",text:`Workset operation failed: ${i.message}`}],isError:!0}}})}function We(t){t.registerTool("check",{description:"Run incremental typecheck (tsc) and lint (biome) on the project or specific files. Returns structured error and warning lists.",inputSchema:{files:r.array(r.string()).optional().describe("Specific files to check (if omitted, checks all)"),cwd:r.string().optional().describe("Working directory"),skip_types:r.boolean().default(!1).describe("Skip TypeScript typecheck"),skip_lint:r.boolean().default(!1).describe("Skip Biome lint")}},async({files:n,cwd:e,skip_types:s,skip_lint:o})=>{try{const i=await m({files:n,cwd:e,skipTypes:s,skipLint:o});return{content:[{type:"text",text:JSON.stringify(i,null,2)}]}}catch(i){return{content:[{type:"text",text:`Check failed: ${i.message}`}],isError:!0}}})}function Ke(t,n,e){t.registerTool("batch",{description:"Execute multiple built-in operations in parallel with concurrency control. Supported operation types: search, find, and check.",inputSchema:{operations:r.array(r.object({id:r.string().describe("Unique ID for this operation"),type:r.enum(["search","find","check"]).describe("Built-in operation type"),args:r.record(r.string(),r.unknown()).describe("Arguments for the operation")})).min(1).describe("Operations to execute"),concurrency:r.number().min(1).max(20).default(4).describe("Max concurrent operations")}},async({operations:s,concurrency:o})=>{try{const i=await b(s,async a=>ve(a,n,e),{concurrency:o});return{content:[{type:"text",text:JSON.stringify(i,null,2)}]}}catch(i){return{content:[{type:"text",text:`Batch failed: ${i.message}`}],isError:!0}}})}function Ue(t,n,e){t.registerTool("symbol",{description:"Resolve a symbol: find where it is defined, who imports it, and where it is referenced. Works on TypeScript and JavaScript codebases.",inputSchema:{name:r.string().describe("Symbol name to look up (function, class, type, etc.)"),limit:r.number().min(1).max(50).default(20).describe("Max results per category")}},async({name:s,limit:o})=>{try{const i=await ge(n,e,{name:s,limit:o});return{content:[{type:"text",text:Oe(i)}]}}catch(i){return{content:[{type:"text",text:`Symbol lookup failed: ${i.message}`}],isError:!0}}})}function Be(t){t.registerTool("eval",{description:"Execute a JavaScript or TypeScript snippet in a constrained VM sandbox with a timeout. Captures console output and returned values.",inputSchema:{code:r.string().describe("Code snippet to execute"),lang:r.enum(["js","ts"]).default("js").optional().describe("Language mode: js executes directly, ts strips common type syntax first"),timeout:r.number().min(1).max(6e4).default(5e3).optional().describe("Execution timeout in milliseconds")}},async({code:n,lang:e,timeout:s})=>{try{const o=_({code:n,lang:e,timeout:s});return o.success?{content:[{type:"text",text:`Eval succeeded in ${o.durationMs}ms
 
-${result.output}`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Eval failed:", err);
-        return {
-          content: [{ type: "text", text: `Eval failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerTestRunTool(server) {
-  server.registerTool(
-    "test_run",
-    {
-      description: "Run Vitest for the current project or a subset of files, then return a structured summary of passing and failing tests.",
-      inputSchema: {
-        files: z.array(z.string()).optional().describe("Specific test files or patterns to run"),
-        grep: z.string().optional().describe("Only run tests whose names match this pattern"),
-        cwd: z.string().optional().describe("Working directory for the test run")
-      }
-    },
-    async ({ files, grep, cwd }) => {
-      try {
-        const result = await testRun({ files, grep, cwd });
-        return {
-          content: [{ type: "text", text: formatTestRunResult(result) }],
-          isError: !result.passed
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Test run failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerStashTool(server) {
-  server.registerTool(
-    "stash",
-    {
-      description: "Persist and retrieve named values in .kb-state/stash.json for intermediate results between tool calls.",
-      inputSchema: {
-        action: z.enum(["set", "get", "list", "delete", "clear"]).describe("Operation to perform on the stash"),
-        key: z.string().optional().describe("Entry key for set/get/delete operations"),
-        value: z.string().optional().describe("String or JSON value for set operations")
-      }
-    },
-    async ({ action, key, value }) => {
-      try {
-        switch (action) {
-          case "set": {
-            if (!key) throw new Error("key required for set");
-            const entry = stashSet(key, parseMaybeJsonString(value ?? ""));
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Stored stash entry "${entry.key}" (${entry.type}) at ${entry.storedAt}.`
-                }
-              ]
-            };
-          }
-          case "get": {
-            if (!key) throw new Error("key required for get");
-            const entry = stashGet(key);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: entry ? JSON.stringify(entry, null, 2) : `Stash entry "${key}" not found.`
-                }
-              ]
-            };
-          }
-          case "list": {
-            const entries = stashList();
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: entries.length === 0 ? "Stash is empty." : entries.map((entry) => `- ${entry.key} (${entry.type}) \u2014 ${entry.storedAt}`).join("\n")
-                }
-              ]
-            };
-          }
-          case "delete": {
-            if (!key) throw new Error("key required for delete");
-            const deleted = stashDelete(key);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: deleted ? `Deleted stash entry "${key}".` : `Stash entry "${key}" not found.`
-                }
-              ]
-            };
-          }
-          case "clear": {
-            const count = stashClear();
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Cleared ${count} stash entr${count === 1 ? "y" : "ies"}.`
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Stash operation failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerGitContextTool(server) {
-  server.registerTool(
-    "git_context",
-    {
-      description: "Summarize the current Git branch, working tree state, recent commits, and optional diff statistics for the repository.",
-      inputSchema: {
-        cwd: z.string().optional().describe("Repository root or working directory"),
-        commit_count: z.number().min(1).max(50).default(5).optional().describe("How many recent commits to include"),
-        include_diff: z.boolean().default(false).optional().describe("Include diff stat for working tree changes")
-      }
-    },
-    async ({ cwd, commit_count, include_diff }) => {
-      try {
-        const result = await gitContext({
-          cwd,
-          commitCount: commit_count,
-          includeDiff: include_diff
-        });
-        return {
-          content: [{ type: "text", text: formatGitContext(result) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Git context failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerDiffParseTool(server) {
-  server.registerTool(
-    "diff_parse",
-    {
-      description: "Parse raw unified diff text into file-level and hunk-level structural changes.",
-      inputSchema: {
-        diff: z.string().describe("Raw unified diff text")
-      }
-    },
-    async ({ diff }) => {
-      try {
-        const normalizedDiff = diff.replace(/\\n/g, "\n").replace(/\\t/g, "	");
-        const files = diffParse({ diff: normalizedDiff });
-        return {
-          content: [{ type: "text", text: formatDiffFiles(files) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Diff parse failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerRenameTool(server) {
-  server.registerTool(
-    "rename",
-    {
-      description: "Rename a symbol across files using whole-word regex matching for exports, imports, and general usage references.",
-      inputSchema: {
-        old_name: z.string().describe("Existing symbol name to replace"),
-        new_name: z.string().describe("New symbol name to use"),
-        root_path: z.string().describe("Root directory to search within"),
-        extensions: z.array(z.string()).optional().describe("Optional file extensions to include, such as .ts,.tsx,.js,.jsx"),
-        dry_run: z.boolean().default(true).describe("Preview changes without writing files")
-      }
-    },
-    async ({ old_name, new_name, root_path, extensions, dry_run }) => {
-      try {
-        const result = await rename({
-          oldName: old_name,
-          newName: new_name,
-          rootPath: root_path,
-          extensions,
-          dryRun: dry_run
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Rename failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerCodemodTool(server) {
-  server.registerTool(
-    "codemod",
-    {
-      description: "Apply regex-based codemod rules across files and return structured before/after changes for each affected line.",
-      inputSchema: {
-        root_path: z.string().describe("Root directory to transform within"),
-        rules: z.array(
-          z.object({
-            description: z.string().describe("What the codemod rule does"),
-            pattern: z.string().describe("Regex pattern in string form"),
-            replacement: z.string().describe("Replacement string with optional capture groups")
-          })
-        ).min(1).describe("Codemod rules to apply"),
-        dry_run: z.boolean().default(true).describe("Preview changes without writing files")
-      }
-    },
-    async ({ root_path, rules, dry_run }) => {
-      try {
-        const result = await codemod({
-          rootPath: root_path,
-          rules,
-          dryRun: dry_run
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Codemod failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerFileSummaryTool(server) {
-  server.registerTool(
-    "file_summary",
-    {
-      description: "Create a concise structural summary of a source file: imports, exports, functions, classes, interfaces, and types.",
-      inputSchema: {
-        path: z.string().describe("Absolute path to the file to summarize")
-      }
-    },
-    async ({ path }) => {
-      try {
-        const summary = await fileSummary({ path });
-        return {
-          content: [{ type: "text", text: formatFileSummary(summary) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `File summary failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerCheckpointTool(server) {
-  server.registerTool(
-    "checkpoint",
-    {
-      description: "Save and restore lightweight session checkpoints in .kb-state/checkpoints for cross-session continuity.",
-      inputSchema: {
-        action: z.enum(["save", "load", "list", "latest"]).describe("Checkpoint action to perform"),
-        label: z.string().optional().describe("Checkpoint label for save, or checkpoint id for load"),
-        data: z.string().optional().describe("JSON object string for save actions"),
-        notes: z.string().optional().describe("Optional notes for save actions")
-      }
-    },
-    async ({ action, label, data, notes }) => {
-      try {
-        switch (action) {
-          case "save": {
-            if (!label) throw new Error("label required for save");
-            const checkpoint = checkpointSave(label, parseRecordString(data), { notes });
-            return {
-              content: [{ type: "text", text: formatCheckpoint(checkpoint) }]
-            };
-          }
-          case "load": {
-            if (!label) throw new Error("label required for load");
-            const checkpoint = checkpointLoad(label);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: checkpoint ? formatCheckpoint(checkpoint) : `Checkpoint "${label}" not found.`
-                }
-              ]
-            };
-          }
-          case "list": {
-            const checkpoints = checkpointList();
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: checkpoints.length === 0 ? "No checkpoints saved." : checkpoints.map(
-                    (checkpoint) => `- ${checkpoint.id} \u2014 ${checkpoint.label} (${checkpoint.createdAt})`
-                  ).join("\n")
-                }
-              ]
-            };
-          }
-          case "latest": {
-            const checkpoint = checkpointLatest();
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: checkpoint ? formatCheckpoint(checkpoint) : "No checkpoints saved."
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Checkpoint failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerDataTransformTool(server) {
-  server.registerTool(
-    "data_transform",
-    {
-      description: "Apply small jq-like transforms to JSON input for filtering, projection, grouping, and path extraction.",
-      inputSchema: {
-        input: z.string().describe("Input JSON string"),
-        expression: z.string().describe("Transform expression to apply")
-      }
-    },
-    async ({ input, expression }) => {
-      try {
-        const result = dataTransform({ input, expression });
-        return {
-          content: [{ type: "text", text: result.outputString }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Data transform failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerTraceTool(server, embedder, store) {
-  server.registerTool(
-    "trace",
-    {
-      description: "Trace data flow through a codebase by following imports, call sites, and references from a starting symbol or file location.",
-      inputSchema: {
-        start: z.string().describe("Starting point \u2014 symbol name or file:line reference"),
-        direction: z.enum(["forward", "backward", "both"]).describe("Which direction to trace relationships"),
-        max_depth: z.number().min(1).max(10).default(3).optional().describe("Maximum trace depth")
-      }
-    },
-    async ({ start, direction, max_depth }) => {
-      try {
-        const result = await trace(embedder, store, {
-          start,
-          direction,
-          maxDepth: max_depth
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Trace failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerFindExamplesTool(server, embedder, store) {
-  server.registerTool(
-    "find_examples",
-    {
-      description: "Find real usage examples of a function, class, or pattern in the indexed codebase.",
-      inputSchema: {
-        query: z.string().describe("Symbol or pattern to find examples of"),
-        limit: z.number().min(1).max(20).default(5).optional().describe("Maximum examples to return"),
-        content_type: z.string().optional().describe("Filter by content type")
-      }
-    },
-    async ({ query, limit, content_type }) => {
-      try {
-        const result = await findExamples(embedder, store, {
-          query,
-          limit,
-          contentType: content_type
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Find examples failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerProcessTool(server) {
-  server.registerTool(
-    "process",
-    {
-      description: "Start, stop, inspect, list, and tail logs for in-memory managed child processes.",
-      inputSchema: {
-        action: z.enum(["start", "stop", "status", "list", "logs"]).describe("Process action to perform"),
-        id: z.string().optional().describe("Managed process ID"),
-        command: z.string().optional().describe("Executable to start"),
-        args: z.array(z.string()).optional().describe("Arguments for start actions"),
-        tail: z.number().min(1).max(500).optional().describe("Log lines to return for logs actions")
-      }
-    },
-    async ({ action, id, command, args, tail }) => {
-      try {
-        switch (action) {
-          case "start": {
-            if (!id || !command) throw new Error("id and command are required for start");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(processStart(id, command, args ?? []), null, 2)
-                }
-              ]
-            };
-          }
-          case "stop": {
-            if (!id) throw new Error("id is required for stop");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(processStop(id) ?? null, null, 2)
-                }
-              ]
-            };
-          }
-          case "status": {
-            if (!id) throw new Error("id is required for status");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(processStatus(id) ?? null, null, 2)
-                }
-              ]
-            };
-          }
-          case "list": {
-            return {
-              content: [{ type: "text", text: JSON.stringify(processList(), null, 2) }]
-            };
-          }
-          case "logs": {
-            if (!id) throw new Error("id is required for logs");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(processLogs(id, tail), null, 2)
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Process action failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerWatchTool(server) {
-  server.registerTool(
-    "watch",
-    {
-      description: "Start, stop, and list in-memory filesystem watchers for a directory.",
-      inputSchema: {
-        action: z.enum(["start", "stop", "list"]).describe("Watch action to perform"),
-        path: z.string().optional().describe("Directory path to watch for start actions"),
-        id: z.string().optional().describe("Watcher ID for stop actions")
-      }
-    },
-    async ({ action, path, id }) => {
-      try {
-        switch (action) {
-          case "start": {
-            if (!path) throw new Error("path is required for start");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(watchStart({ path }), null, 2)
-                }
-              ]
-            };
-          }
-          case "stop": {
-            if (!id) throw new Error("id is required for stop");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({ stopped: watchStop(id) }, null, 2)
-                }
-              ]
-            };
-          }
-          case "list": {
-            return {
-              content: [{ type: "text", text: JSON.stringify(watchList(), null, 2) }]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Watch action failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerDeadSymbolsTool(server, embedder, store) {
-  server.registerTool(
-    "dead_symbols",
-    {
-      description: "Find exported symbols that appear to be unused because they are never imported or re-exported.",
-      inputSchema: {
-        limit: z.number().min(1).max(500).default(100).optional().describe("Maximum exported symbols to scan")
-      }
-    },
-    async ({ limit }) => {
-      try {
-        const result = await findDeadSymbols(embedder, store, { limit });
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Dead symbol scan failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerDelegateTool(server) {
-  server.registerTool(
-    "delegate",
-    {
-      description: "Delegate a subtask to a local Ollama model. Use for summarization, classification, naming, or any task that can offload work from the host agent. Fails fast if Ollama is not running.",
-      inputSchema: {
-        prompt: z.string().describe("The task or question to send to the local model"),
-        model: z.string().optional().describe("Ollama model name (default: first available model)"),
-        system: z.string().optional().describe("System prompt for the model"),
-        context: z.string().optional().describe("Context text to include before the prompt (e.g. file contents)"),
-        temperature: z.number().min(0).max(2).default(0.3).optional().describe("Sampling temperature (0=deterministic, default 0.3)"),
-        timeout: z.number().min(1e3).max(6e5).default(12e4).optional().describe("Timeout in milliseconds (default 120000)"),
-        action: z.enum(["generate", "list_models"]).default("generate").optional().describe("Action: generate a response or list available models")
-      }
-    },
-    async ({ prompt, model, system, context, temperature, timeout, action }) => {
-      try {
-        if (action === "list_models") {
-          const models = await delegateListModels();
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  { models, count: models.length, _Next: "Use delegate with a model name" },
-                  null,
-                  2
-                )
-              }
-            ]
-          };
-        }
-        const result = await delegate({ prompt, model, system, context, temperature, timeout });
-        if (result.error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  { error: result.error, model: result.model, durationMs: result.durationMs },
-                  null,
-                  2
-                )
-              }
-            ],
-            isError: true
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  model: result.model,
-                  response: result.response,
-                  durationMs: result.durationMs,
-                  tokenCount: result.tokenCount,
-                  _Next: "Use the response in your workflow. stash to save it."
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Delegate failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerLaneTool(server) {
-  server.registerTool(
-    "lane",
-    {
-      description: "Manage verified lanes \u2014 isolated file copies for parallel exploration. Create a lane, make changes, diff, merge back, or discard.",
-      inputSchema: {
-        action: z.enum(["create", "list", "status", "diff", "merge", "discard"]).describe("Lane action to perform"),
-        name: z.string().optional().describe("Lane name (required for create/status/diff/merge/discard)"),
-        files: z.array(z.string()).optional().describe("File paths to copy into the lane (required for create)")
-      }
-    },
-    async ({ action, name, files }) => {
-      try {
-        switch (action) {
-          case "create": {
-            if (!name) throw new Error("name is required for create");
-            if (!files || files.length === 0) throw new Error("files are required for create");
-            const meta = laneCreate(name, files);
-            return {
-              content: [{ type: "text", text: JSON.stringify(meta, null, 2) }]
-            };
-          }
-          case "list": {
-            return {
-              content: [{ type: "text", text: JSON.stringify(laneList(), null, 2) }]
-            };
-          }
-          case "status": {
-            if (!name) throw new Error("name is required for status");
-            return {
-              content: [{ type: "text", text: JSON.stringify(laneStatus(name), null, 2) }]
-            };
-          }
-          case "diff": {
-            if (!name) throw new Error("name is required for diff");
-            return {
-              content: [{ type: "text", text: JSON.stringify(laneDiff(name), null, 2) }]
-            };
-          }
-          case "merge": {
-            if (!name) throw new Error("name is required for merge");
-            return {
-              content: [{ type: "text", text: JSON.stringify(laneMerge(name), null, 2) }]
-            };
-          }
-          case "discard": {
-            if (!name) throw new Error("name is required for discard");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({ discarded: laneDiscard(name) }, null, 2)
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Lane action failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerHealthTool(server) {
-  server.registerTool(
-    "health",
-    {
-      description: "Run project health checks \u2014 verifies package.json, tsconfig, scripts, lockfile, README, LICENSE, .gitignore.",
-      inputSchema: {
-        path: z.string().optional().describe("Root directory to check (defaults to cwd)")
-      }
-    },
-    async ({ path }) => {
-      try {
-        const result = health(path);
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Health check failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerQueueTool(server) {
-  server.registerTool(
-    "queue",
-    {
-      description: "Manage task queues for sequential agent operations. Push items, take next, mark done/failed, list queues.",
-      inputSchema: {
-        action: z.enum(["create", "push", "next", "done", "fail", "get", "list", "clear", "delete"]).describe("Queue action"),
-        name: z.string().optional().describe("Queue name (required for most actions)"),
-        title: z.string().optional().describe("Item title (required for push)"),
-        id: z.string().optional().describe("Item ID (required for done/fail)"),
-        data: z.unknown().optional().describe("Arbitrary data to attach to a queue item"),
-        error: z.string().optional().describe("Error message (required for fail)")
-      }
-    },
-    async ({ action, name, title, id, data, error }) => {
-      try {
-        switch (action) {
-          case "create": {
-            if (!name) throw new Error("name is required for create");
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(queueCreate(name), null, 2) }
-              ]
-            };
-          }
-          case "push": {
-            if (!name) throw new Error("name is required for push");
-            if (!title) throw new Error("title is required for push");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(queuePush(name, title, data), null, 2)
-                }
-              ]
-            };
-          }
-          case "next": {
-            if (!name) throw new Error("name is required for next");
-            const item = queueNext(name);
-            return {
-              content: [{ type: "text", text: JSON.stringify(item, null, 2) }]
-            };
-          }
-          case "done": {
-            if (!name) throw new Error("name is required for done");
-            if (!id) throw new Error("id is required for done");
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(queueDone(name, id), null, 2) }
-              ]
-            };
-          }
-          case "fail": {
-            if (!name) throw new Error("name is required for fail");
-            if (!id) throw new Error("id is required for fail");
-            if (!error) throw new Error("error is required for fail");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(queueFail(name, id, error), null, 2)
-                }
-              ]
-            };
-          }
-          case "get": {
-            if (!name) throw new Error("name is required for get");
-            return {
-              content: [{ type: "text", text: JSON.stringify(queueGet(name), null, 2) }]
-            };
-          }
-          case "list": {
-            return {
-              content: [{ type: "text", text: JSON.stringify(queueList(), null, 2) }]
-            };
-          }
-          case "clear": {
-            if (!name) throw new Error("name is required for clear");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({ cleared: queueClear(name) }, null, 2)
-                }
-              ]
-            };
-          }
-          case "delete": {
-            if (!name) throw new Error("name is required for delete");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({ deleted: queueDelete(name) }, null, 2)
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Queue action failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-const searchArgsSchema = z.object({
-  query: z.string(),
-  limit: z.number().min(1).max(20).default(5).optional(),
-  search_mode: z.enum(["hybrid", "semantic", "keyword"]).default("hybrid").optional(),
-  content_type: z.string().optional(),
-  origin: z.enum(["indexed", "curated", "produced"]).optional(),
-  category: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  min_score: z.number().min(0).max(1).default(0.25).optional()
-});
-const findArgsSchema = z.object({
-  query: z.string().optional(),
-  glob: z.string().optional(),
-  pattern: z.string().optional(),
-  limit: z.number().min(1).max(50).default(10).optional(),
-  content_type: z.string().optional(),
-  cwd: z.string().optional()
-});
-const checkArgsSchema = z.object({
-  files: z.array(z.string()).optional(),
-  cwd: z.string().optional(),
-  skip_types: z.boolean().optional(),
-  skip_lint: z.boolean().optional()
-});
-async function executeToolkitBatchOperation(operation, embedder, store) {
-  switch (operation.type) {
-    case "search": {
-      const args = searchArgsSchema.parse(operation.args);
-      return executeBatchSearch(embedder, store, args);
-    }
-    case "find": {
-      const args = findArgsSchema.parse(operation.args);
-      if (!args.query && !args.glob && !args.pattern) {
-        throw new Error("find operation requires query, glob, or pattern");
-      }
-      return find(embedder, store, {
-        query: args.query,
-        glob: args.glob,
-        pattern: args.pattern,
-        limit: args.limit,
-        contentType: args.content_type,
-        cwd: args.cwd
-      });
-    }
-    case "check": {
-      const args = checkArgsSchema.parse(operation.args);
-      return check({
-        files: args.files,
-        cwd: args.cwd,
-        skipTypes: args.skip_types,
-        skipLint: args.skip_lint
-      });
-    }
-    default:
-      throw new Error(`Unsupported batch operation type: ${operation.type}`);
-  }
-}
-async function executeBatchSearch(embedder, store, args) {
-  const limit = args.limit ?? 5;
-  const filterOptions = {
-    limit,
-    minScore: args.min_score ?? 0.25,
-    contentType: args.content_type,
-    origin: args.origin,
-    category: args.category,
-    tags: args.tags
-  };
-  const embedQuery = embedder.embedQuery?.bind(embedder) ?? embedder.embed.bind(embedder);
-  if (args.search_mode === "keyword") {
-    return (await store.ftsSearch(args.query, filterOptions)).slice(0, limit);
-  }
-  const queryVector = await embedQuery(args.query);
-  if (args.search_mode === "semantic") {
-    return store.search(queryVector, filterOptions);
-  }
-  const [vectorResults, ftsResults] = await Promise.all([
-    store.search(queryVector, { ...filterOptions, limit: limit * 2 }),
-    store.ftsSearch(args.query, { ...filterOptions, limit: limit * 2 })
-  ]);
-  return reciprocalRankFusion(vectorResults, ftsResults).slice(0, limit);
-}
-function reciprocalRankFusion(vectorResults, ftsResults, k = 60) {
-  const merged = /* @__PURE__ */ new Map();
-  for (let index = 0; index < vectorResults.length; index++) {
-    const result = vectorResults[index];
-    merged.set(result.record.id, { record: result.record, score: 1 / (k + index + 1) });
-  }
-  for (let index = 0; index < ftsResults.length; index++) {
-    const result = ftsResults[index];
-    const existing = merged.get(result.record.id);
-    if (existing) {
-      existing.score += 1 / (k + index + 1);
-      continue;
-    }
-    merged.set(result.record.id, { record: result.record, score: 1 / (k + index + 1) });
-  }
-  return [...merged.values()].sort((a, b) => b.score - a.score);
-}
-function formatSymbolInfo(info) {
-  const lines = [`Symbol: ${info.name}`];
-  if (info.definedIn) {
-    lines.push(
-      `Defined in: ${info.definedIn.path}:${info.definedIn.line} (${info.definedIn.kind})`
-    );
-  } else {
-    lines.push("Defined in: not found");
-  }
-  lines.push("", "Imported by:");
-  if (info.importedBy.length === 0) {
-    lines.push("  none");
-  } else {
-    for (const item of info.importedBy) {
-      lines.push(`  - ${item.path}:${item.line} ${item.importStatement}`);
-    }
-  }
-  lines.push("", "Referenced in:");
-  if (info.referencedIn.length === 0) {
-    lines.push("  none");
-  } else {
-    for (const item of info.referencedIn) {
-      lines.push(`  - ${item.path}:${item.line} ${item.context}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatTestRunResult(result) {
-  const lines = [
-    `Vitest run: ${result.passed ? "passed" : "failed"}`,
-    `Duration: ${result.durationMs}ms`,
-    `Passed: ${result.summary.passed}`,
-    `Failed: ${result.summary.failed}`,
-    `Skipped: ${result.summary.skipped}`
-  ];
-  if (result.summary.suites !== void 0) {
-    lines.push(`Suites: ${result.summary.suites}`);
-  }
-  const failedTests = result.summary.tests.filter((test) => test.status === "fail");
-  if (failedTests.length > 0) {
-    lines.push("", "Failed tests:");
-    for (const test of failedTests) {
-      lines.push(`- ${test.name}${test.file ? ` (${test.file})` : ""}`);
-      if (test.error) lines.push(`  ${test.error}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatGitContext(result) {
-  const lines = [
-    `Branch: ${result.branch}`,
-    `Staged: ${result.status.staged.length}`,
-    ...result.status.staged.map((file) => `  - ${file}`),
-    `Modified: ${result.status.modified.length}`,
-    ...result.status.modified.map((file) => `  - ${file}`),
-    `Untracked: ${result.status.untracked.length}`,
-    ...result.status.untracked.map((file) => `  - ${file}`),
-    "",
-    "Recent commits:"
-  ];
-  if (result.recentCommits.length === 0) {
-    lines.push("  none");
-  } else {
-    for (const commit of result.recentCommits) {
-      lines.push(`  - ${commit.hash} ${commit.message}`);
-      lines.push(`    ${commit.author} @ ${commit.date}`);
-    }
-  }
-  if (result.diff) {
-    lines.push("", "Diff stat:", result.diff);
-  }
-  return lines.join("\n");
-}
-function formatDiffFiles(files) {
-  if (files.length === 0) {
-    return "No diff files found.";
-  }
-  const lines = [];
-  for (const file of files) {
-    const renameInfo = file.oldPath ? ` (from ${file.oldPath})` : "";
-    lines.push(
-      `${file.path}${renameInfo} [${file.status}] +${file.additions} -${file.deletions} (${file.hunks.length} hunks)`
-    );
-    for (const hunk of file.hunks) {
-      const suffix = hunk.header ? ` ${hunk.header}` : "";
-      lines.push(
-        `  @@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@${suffix}`
-      );
-    }
-  }
-  return lines.join("\n");
-}
-function formatFileSummary(summary) {
-  const lines = [
-    summary.path,
-    `Language: ${summary.language}`,
-    `Lines: ${summary.lines}`,
-    `Estimated tokens: ~${summary.estimatedTokens}`,
-    "",
-    `Imports (${summary.imports.length}):`,
-    ...formatIndentedList(summary.imports),
-    "",
-    `Exports (${summary.exports.length}):`,
-    ...formatIndentedList(summary.exports),
-    "",
-    `Functions (${summary.functions.length}):`,
-    ...formatIndentedList(
-      summary.functions.map(
-        (item) => `${item.name} @ line ${item.line}${item.exported ? " [exported]" : ""}`
-      )
-    ),
-    "",
-    `Classes (${summary.classes.length}):`,
-    ...formatIndentedList(
-      summary.classes.map(
-        (item) => `${item.name} @ line ${item.line}${item.exported ? " [exported]" : ""}`
-      )
-    ),
-    "",
-    `Interfaces (${summary.interfaces.length}):`,
-    ...formatIndentedList(summary.interfaces.map((item) => `${item.name} @ line ${item.line}`)),
-    "",
-    `Types (${summary.types.length}):`,
-    ...formatIndentedList(summary.types.map((item) => `${item.name} @ line ${item.line}`))
-  ];
-  return lines.join("\n");
-}
-function formatCheckpoint(checkpoint) {
-  const lines = [checkpoint.id, `Label: ${checkpoint.label}`, `Created: ${checkpoint.createdAt}`];
-  if (checkpoint.notes) lines.push(`Notes: ${checkpoint.notes}`);
-  if (checkpoint.files?.length) {
-    lines.push(`Files: ${checkpoint.files.length}`);
-    for (const file of checkpoint.files) lines.push(`  - ${file}`);
-  }
-  lines.push("", "Data:", JSON.stringify(checkpoint.data, null, 2));
-  return lines.join("\n");
-}
-function formatIndentedList(items) {
-  return items.length === 0 ? ["  none"] : items.map((item) => `  - ${item}`);
-}
-function parseMaybeJsonString(value) {
-  const trimmed = value.trim();
-  if (!trimmed) return "";
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return value;
-  }
-}
-function parseRecordString(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) return {};
-  const parsed = JSON.parse(trimmed);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("data must be a JSON object string");
-  }
-  return parsed;
-}
-function registerWebFetchTool(server) {
-  server.registerTool(
-    "web_fetch",
-    {
-      description: "PREFERRED web fetcher \u2014 fetch any URL and convert to LLM-optimized markdown. Supports CSS selectors, 4 output modes (markdown/raw/links/outline), smart paragraph-boundary truncation. Strips scripts/styles/nav automatically.",
-      inputSchema: {
-        url: z.string().url().describe("URL to fetch (http/https only)"),
-        mode: z.enum(["markdown", "raw", "links", "outline"]).default("markdown").describe(
-          "Output mode: markdown (clean content), raw (HTML), links (extracted URLs), outline (heading hierarchy)"
-        ),
-        selector: z.string().optional().describe(
-          "CSS selector to extract a specific element instead of auto-detecting main content"
-        ),
-        max_length: z.number().min(500).max(1e5).default(15e3).describe("Max characters in output \u2014 truncates at paragraph boundaries"),
-        include_metadata: z.boolean().default(true).describe("Include page title, description, and URL as a header"),
-        include_links: z.boolean().default(false).describe("Append extracted links list at the end"),
-        include_images: z.boolean().default(false).describe("Include image alt texts inline"),
-        timeout: z.number().min(1e3).max(6e4).default(15e3).describe("Request timeout in milliseconds")
-      }
-    },
-    async ({
-      url,
-      mode,
-      selector,
-      max_length,
-      include_metadata,
-      include_links,
-      include_images,
-      timeout
-    }) => {
-      try {
-        const result = await webFetch({
-          url,
-          mode,
-          selector,
-          maxLength: max_length,
-          includeMetadata: include_metadata,
-          includeLinks: include_links,
-          includeImages: include_images,
-          timeout
-        });
-        const meta = [`## ${result.title || "Web Page"}`, "", result.content];
-        if (result.truncated) {
-          meta.push("", `_Original length: ${result.originalLength.toLocaleString()} chars_`);
-        }
-        meta.push(
-          "",
-          "---",
-          `_Next: Use \`remember\` to save key findings, or \`web_fetch\` with a \`selector\` to extract a specific section._`
-        );
-        return {
-          content: [{ type: "text", text: meta.join("\n") }]
-        };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Web fetch failed: ${err.message}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerBatchTool,
-  registerCheckTool,
-  registerCheckpointTool,
-  registerCodemodTool,
-  registerCompactTool,
-  registerDataTransformTool,
-  registerDeadSymbolsTool,
-  registerDelegateTool,
-  registerDiffParseTool,
-  registerEvalTool,
-  registerFileSummaryTool,
-  registerFindExamplesTool,
-  registerFindTool,
-  registerGitContextTool,
-  registerHealthTool,
-  registerLaneTool,
-  registerParseOutputTool,
-  registerProcessTool,
-  registerQueueTool,
-  registerRenameTool,
-  registerScopeMapTool,
-  registerStashTool,
-  registerSymbolTool,
-  registerTestRunTool,
-  registerTraceTool,
-  registerWatchTool,
-  registerWebFetchTool,
-  registerWorksetTool
-};
-//# sourceMappingURL=toolkit.tools.js.map
+${o.output}`}]}:{content:[{type:"text",text:`Eval failed in ${o.durationMs}ms: ${o.error??"Unknown error"}`}],isError:!0}}catch(o){return console.error("[KB] Eval failed:",o),{content:[{type:"text",text:`Eval failed: ${o.message}`}],isError:!0}}})}function ze(t){t.registerTool("test_run",{description:"Run Vitest for the current project or a subset of files, then return a structured summary of passing and failing tests.",inputSchema:{files:r.array(r.string()).optional().describe("Specific test files or patterns to run"),grep:r.string().optional().describe("Only run tests whose names match this pattern"),cwd:r.string().optional().describe("Working directory for the test run")}},async({files:n,grep:e,cwd:s})=>{try{const o=await he({files:n,grep:e,cwd:s});return{content:[{type:"text",text:Me(o)}],isError:!o.passed}}catch(o){return{content:[{type:"text",text:`Test run failed: ${o.message}`}],isError:!0}}})}function Ge(t){t.registerTool("stash",{description:"Persist and retrieve named values in .kb-state/stash.json for intermediate results between tool calls.",inputSchema:{action:r.enum(["set","get","list","delete","clear"]).describe("Operation to perform on the stash"),key:r.string().optional().describe("Entry key for set/get/delete operations"),value:r.string().optional().describe("String or JSON value for set operations")}},async({action:n,key:e,value:s})=>{try{switch(n){case"set":{if(!e)throw new Error("key required for set");const o=me(e,Ie(s??""));return{content:[{type:"text",text:`Stored stash entry "${o.key}" (${o.type}) at ${o.storedAt}.`}]}}case"get":{if(!e)throw new Error("key required for get");const o=pe(e);return{content:[{type:"text",text:o?JSON.stringify(o,null,2):`Stash entry "${e}" not found.`}]}}case"list":{const o=fe();return{content:[{type:"text",text:o.length===0?"Stash is empty.":o.map(i=>`- ${i.key} (${i.type}) \u2014 ${i.storedAt}`).join(`
+`)}]}}case"delete":{if(!e)throw new Error("key required for delete");return{content:[{type:"text",text:ue(e)?`Deleted stash entry "${e}".`:`Stash entry "${e}" not found.`}]}}case"clear":{const o=de();return{content:[{type:"text",text:`Cleared ${o} stash entr${o===1?"y":"ies"}.`}]}}}}catch(o){return{content:[{type:"text",text:`Stash operation failed: ${o.message}`}],isError:!0}}})}function Qe(t){t.registerTool("git_context",{description:"Summarize the current Git branch, working tree state, recent commits, and optional diff statistics for the repository.",inputSchema:{cwd:r.string().optional().describe("Repository root or working directory"),commit_count:r.number().min(1).max(50).default(5).optional().describe("How many recent commits to include"),include_diff:r.boolean().default(!1).optional().describe("Include diff stat for working tree changes")}},async({cwd:n,commit_count:e,include_diff:s})=>{try{const o=await j({cwd:n,commitCount:e,includeDiff:s});return{content:[{type:"text",text:Ne(o)}]}}catch(o){return{content:[{type:"text",text:`Git context failed: ${o.message}`}],isError:!0}}})}function He(t){t.registerTool("diff_parse",{description:"Parse raw unified diff text into file-level and hunk-level structural changes.",inputSchema:{diff:r.string().describe("Raw unified diff text")}},async({diff:n})=>{try{const e=n.replace(/\\n/g,`
+`).replace(/\\t/g,"	"),s=N({diff:e});return{content:[{type:"text",text:_e(s)}]}}catch(e){return{content:[{type:"text",text:`Diff parse failed: ${e.message}`}],isError:!0}}})}function Ve(t){t.registerTool("rename",{description:"Rename a symbol across files using whole-word regex matching for exports, imports, and general usage references.",inputSchema:{old_name:r.string().describe("Existing symbol name to replace"),new_name:r.string().describe("New symbol name to use"),root_path:r.string().describe("Root directory to search within"),extensions:r.array(r.string()).optional().describe("Optional file extensions to include, such as .ts,.tsx,.js,.jsx"),dry_run:r.boolean().default(!0).describe("Preview changes without writing files")}},async({old_name:n,new_name:e,root_path:s,extensions:o,dry_run:i})=>{try{const a=await ae({oldName:n,newName:e,rootPath:s,extensions:o,dryRun:i});return{content:[{type:"text",text:JSON.stringify(a,null,2)}]}}catch(a){return{content:[{type:"text",text:`Rename failed: ${a.message}`}],isError:!0}}})}function Xe(t){t.registerTool("codemod",{description:"Apply regex-based codemod rules across files and return structured before/after changes for each affected line.",inputSchema:{root_path:r.string().describe("Root directory to transform within"),rules:r.array(r.object({description:r.string().describe("What the codemod rule does"),pattern:r.string().describe("Regex pattern in string form"),replacement:r.string().describe("Replacement string with optional capture groups")})).min(1).describe("Codemod rules to apply"),dry_run:r.boolean().default(!0).describe("Preview changes without writing files")}},async({root_path:n,rules:e,dry_run:s})=>{try{const o=await E({rootPath:n,rules:e,dryRun:s});return{content:[{type:"text",text:JSON.stringify(o,null,2)}]}}catch(o){return{content:[{type:"text",text:`Codemod failed: ${o.message}`}],isError:!0}}})}function Ye(t){t.registerTool("file_summary",{description:"Create a concise structural summary of a source file: imports, exports, functions, classes, interfaces, and types.",inputSchema:{path:r.string().describe("Absolute path to the file to summarize")}},async({path:n})=>{try{const e=await R({path:n});return{content:[{type:"text",text:Re(e)}]}}catch(e){return{content:[{type:"text",text:`File summary failed: ${e.message}`}],isError:!0}}})}function Ze(t){t.registerTool("checkpoint",{description:"Save and restore lightweight session checkpoints in .kb-state/checkpoints for cross-session continuity.",inputSchema:{action:r.enum(["save","load","list","latest"]).describe("Checkpoint action to perform"),label:r.string().optional().describe("Checkpoint label for save, or checkpoint id for load"),data:r.string().optional().describe("JSON object string for save actions"),notes:r.string().optional().describe("Optional notes for save actions")}},async({action:n,label:e,data:s,notes:o})=>{try{switch(n){case"save":{if(!e)throw new Error("label required for save");const i=k(e,Je(s),{notes:o});return{content:[{type:"text",text:f(i)}]}}case"load":{if(!e)throw new Error("label required for load");const i=$(e);return{content:[{type:"text",text:i?f(i):`Checkpoint "${e}" not found.`}]}}case"list":{const i=S();return{content:[{type:"text",text:i.length===0?"No checkpoints saved.":i.map(a=>`- ${a.id} \u2014 ${a.label} (${a.createdAt})`).join(`
+`)}]}}case"latest":{const i=w();return{content:[{type:"text",text:i?f(i):"No checkpoints saved."}]}}}}catch(i){return{content:[{type:"text",text:`Checkpoint failed: ${i.message}`}],isError:!0}}})}function et(t){t.registerTool("data_transform",{description:"Apply small jq-like transforms to JSON input for filtering, projection, grouping, and path extraction.",inputSchema:{input:r.string().describe("Input JSON string"),expression:r.string().describe("Transform expression to apply")}},async({input:n,expression:e})=>{try{return{content:[{type:"text",text:T({input:n,expression:e}).outputString}]}}catch(s){return{content:[{type:"text",text:`Data transform failed: ${s.message}`}],isError:!0}}})}function tt(t,n,e){t.registerTool("trace",{description:"Trace data flow through a codebase by following imports, call sites, and references from a starting symbol or file location.",inputSchema:{start:r.string().describe("Starting point \u2014 symbol name or file:line reference"),direction:r.enum(["forward","backward","both"]).describe("Which direction to trace relationships"),max_depth:r.number().min(1).max(10).default(3).optional().describe("Maximum trace depth")}},async({start:s,direction:o,max_depth:i})=>{try{const a=await ye(n,e,{start:s,direction:o,maxDepth:i});return{content:[{type:"text",text:JSON.stringify(a,null,2)}]}}catch(a){return{content:[{type:"text",text:`Trace failed: ${a.message}`}],isError:!0}}})}function rt(t,n,e){t.registerTool("find_examples",{description:"Find real usage examples of a function, class, or pattern in the indexed codebase.",inputSchema:{query:r.string().describe("Symbol or pattern to find examples of"),limit:r.number().min(1).max(20).default(5).optional().describe("Maximum examples to return"),content_type:r.string().optional().describe("Filter by content type")}},async({query:s,limit:o,content_type:i})=>{try{const a=await J(n,e,{query:s,limit:o,contentType:i});return{content:[{type:"text",text:JSON.stringify(a,null,2)}]}}catch(a){return{content:[{type:"text",text:`Find examples failed: ${a.message}`}],isError:!0}}})}function nt(t){t.registerTool("process",{description:"Start, stop, inspect, list, and tail logs for in-memory managed child processes.",inputSchema:{action:r.enum(["start","stop","status","list","logs"]).describe("Process action to perform"),id:r.string().optional().describe("Managed process ID"),command:r.string().optional().describe("Executable to start"),args:r.array(r.string()).optional().describe("Arguments for start actions"),tail:r.number().min(1).max(500).optional().describe("Log lines to return for logs actions")}},async({action:n,id:e,command:s,args:o,tail:i})=>{try{switch(n){case"start":{if(!e||!s)throw new Error("id and command are required for start");return{content:[{type:"text",text:JSON.stringify(Q(e,s,o??[]),null,2)}]}}case"stop":{if(!e)throw new Error("id is required for stop");return{content:[{type:"text",text:JSON.stringify(V(e)??null,null,2)}]}}case"status":{if(!e)throw new Error("id is required for status");return{content:[{type:"text",text:JSON.stringify(H(e)??null,null,2)}]}}case"list":return{content:[{type:"text",text:JSON.stringify(z(),null,2)}]};case"logs":{if(!e)throw new Error("id is required for logs");return{content:[{type:"text",text:JSON.stringify(G(e,i),null,2)}]}}}}catch(a){return{content:[{type:"text",text:`Process action failed: ${a.message}`}],isError:!0}}})}function ot(t){t.registerTool("watch",{description:"Start, stop, and list in-memory filesystem watchers for a directory.",inputSchema:{action:r.enum(["start","stop","list"]).describe("Watch action to perform"),path:r.string().optional().describe("Directory path to watch for start actions"),id:r.string().optional().describe("Watcher ID for stop actions")}},async({action:n,path:e,id:s})=>{try{switch(n){case"start":{if(!e)throw new Error("path is required for start");return{content:[{type:"text",text:JSON.stringify(be({path:e}),null,2)}]}}case"stop":{if(!s)throw new Error("id is required for stop");return{content:[{type:"text",text:JSON.stringify({stopped:we(s)},null,2)}]}}case"list":return{content:[{type:"text",text:JSON.stringify(xe(),null,2)}]}}}catch(o){return{content:[{type:"text",text:`Watch action failed: ${o.message}`}],isError:!0}}})}function st(t,n,e){t.registerTool("dead_symbols",{description:"Find exported symbols that appear to be unused because they are never imported or re-exported.",inputSchema:{limit:r.number().min(1).max(500).default(100).optional().describe("Maximum exported symbols to scan")}},async({limit:s})=>{try{const o=await I(n,e,{limit:s});return{content:[{type:"text",text:JSON.stringify(o,null,2)}]}}catch(o){return{content:[{type:"text",text:`Dead symbol scan failed: ${o.message}`}],isError:!0}}})}function it(t){t.registerTool("delegate",{description:"Delegate a subtask to a local Ollama model. Use for summarization, classification, naming, or any task that can offload work from the host agent. Fails fast if Ollama is not running.",inputSchema:{prompt:r.string().describe("The task or question to send to the local model"),model:r.string().optional().describe("Ollama model name (default: first available model)"),system:r.string().optional().describe("System prompt for the model"),context:r.string().optional().describe("Context text to include before the prompt (e.g. file contents)"),temperature:r.number().min(0).max(2).default(.3).optional().describe("Sampling temperature (0=deterministic, default 0.3)"),timeout:r.number().min(1e3).max(6e5).default(12e4).optional().describe("Timeout in milliseconds (default 120000)"),action:r.enum(["generate","list_models"]).default("generate").optional().describe("Action: generate a response or list available models")}},async({prompt:n,model:e,system:s,context:o,temperature:i,timeout:a,action:l})=>{try{if(l==="list_models"){const u=await O();return{content:[{type:"text",text:JSON.stringify({models:u,count:u.length,_Next:"Use delegate with a model name"},null,2)}]}}const c=await q({prompt:n,model:e,system:s,context:o,temperature:i,timeout:a});return c.error?{content:[{type:"text",text:JSON.stringify({error:c.error,model:c.model,durationMs:c.durationMs},null,2)}],isError:!0}:{content:[{type:"text",text:JSON.stringify({model:c.model,response:c.response,durationMs:c.durationMs,tokenCount:c.tokenCount,_Next:"Use the response in your workflow. stash to save it."},null,2)}]}}catch(c){return{content:[{type:"text",text:`Delegate failed: ${c.message}`}],isError:!0}}})}function at(t){t.registerTool("lane",{description:"Manage verified lanes \u2014 isolated file copies for parallel exploration. Create a lane, make changes, diff, merge back, or discard.",inputSchema:{action:r.enum(["create","list","status","diff","merge","discard"]).describe("Lane action to perform"),name:r.string().optional().describe("Lane name (required for create/status/diff/merge/discard)"),files:r.array(r.string()).optional().describe("File paths to copy into the lane (required for create)")}},async({action:n,name:e,files:s})=>{try{switch(n){case"create":{if(!e)throw new Error("name is required for create");if(!s||s.length===0)throw new Error("files are required for create");const o=F(e,s);return{content:[{type:"text",text:JSON.stringify(o,null,2)}]}}case"list":return{content:[{type:"text",text:JSON.stringify(P(),null,2)}]};case"status":{if(!e)throw new Error("name is required for status");return{content:[{type:"text",text:JSON.stringify(K(e),null,2)}]}}case"diff":{if(!e)throw new Error("name is required for diff");return{content:[{type:"text",text:JSON.stringify(D(e),null,2)}]}}case"merge":{if(!e)throw new Error("name is required for merge");return{content:[{type:"text",text:JSON.stringify(W(e),null,2)}]}}case"discard":{if(!e)throw new Error("name is required for discard");return{content:[{type:"text",text:JSON.stringify({discarded:A(e)},null,2)}]}}}}catch(o){return{content:[{type:"text",text:`Lane action failed: ${o.message}`}],isError:!0}}})}function ct(t){t.registerTool("health",{description:"Run project health checks \u2014 verifies package.json, tsconfig, scripts, lockfile, README, LICENSE, .gitignore.",inputSchema:{path:r.string().optional().describe("Root directory to check (defaults to cwd)")}},async({path:n})=>{try{const e=L(n);return{content:[{type:"text",text:JSON.stringify(e,null,2)}]}}catch(e){return{content:[{type:"text",text:`Health check failed: ${e.message}`}],isError:!0}}})}function lt(t){t.registerTool("queue",{description:"Manage task queues for sequential agent operations. Push items, take next, mark done/failed, list queues.",inputSchema:{action:r.enum(["create","push","next","done","fail","get","list","clear","delete"]).describe("Queue action"),name:r.string().optional().describe("Queue name (required for most actions)"),title:r.string().optional().describe("Item title (required for push)"),id:r.string().optional().describe("Item ID (required for done/fail)"),data:r.unknown().optional().describe("Arbitrary data to attach to a queue item"),error:r.string().optional().describe("Error message (required for fail)")}},async({action:n,name:e,title:s,id:o,data:i,error:a})=>{try{switch(n){case"create":{if(!e)throw new Error("name is required for create");return{content:[{type:"text",text:JSON.stringify(Y(e),null,2)}]}}case"push":{if(!e)throw new Error("name is required for push");if(!s)throw new Error("title is required for push");return{content:[{type:"text",text:JSON.stringify(se(e,s,i),null,2)}]}}case"next":{if(!e)throw new Error("name is required for next");const l=oe(e);return{content:[{type:"text",text:JSON.stringify(l,null,2)}]}}case"done":{if(!e)throw new Error("name is required for done");if(!o)throw new Error("id is required for done");return{content:[{type:"text",text:JSON.stringify(ee(e,o),null,2)}]}}case"fail":{if(!e)throw new Error("name is required for fail");if(!o)throw new Error("id is required for fail");if(!a)throw new Error("error is required for fail");return{content:[{type:"text",text:JSON.stringify(te(e,o,a),null,2)}]}}case"get":{if(!e)throw new Error("name is required for get");return{content:[{type:"text",text:JSON.stringify(re(e),null,2)}]}}case"list":return{content:[{type:"text",text:JSON.stringify(ne(),null,2)}]};case"clear":{if(!e)throw new Error("name is required for clear");return{content:[{type:"text",text:JSON.stringify({cleared:X(e)},null,2)}]}}case"delete":{if(!e)throw new Error("name is required for delete");return{content:[{type:"text",text:JSON.stringify({deleted:Z(e)},null,2)}]}}}}catch(l){return{content:[{type:"text",text:`Queue action failed: ${l.message}`}],isError:!0}}})}const $e=r.object({query:r.string(),limit:r.number().min(1).max(20).default(5).optional(),search_mode:r.enum(["hybrid","semantic","keyword"]).default("hybrid").optional(),content_type:r.string().optional(),origin:r.enum(["indexed","curated","produced"]).optional(),category:r.string().optional(),tags:r.array(r.string()).optional(),min_score:r.number().min(0).max(1).default(.25).optional()}),ke=r.object({query:r.string().optional(),glob:r.string().optional(),pattern:r.string().optional(),limit:r.number().min(1).max(50).default(10).optional(),content_type:r.string().optional(),cwd:r.string().optional()}),Ee=r.object({files:r.array(r.string()).optional(),cwd:r.string().optional(),skip_types:r.boolean().optional(),skip_lint:r.boolean().optional()});async function ve(t,n,e){switch(t.type){case"search":{const s=$e.parse(t.args);return Te(n,e,s)}case"find":{const s=ke.parse(t.args);if(!s.query&&!s.glob&&!s.pattern)throw new Error("find operation requires query, glob, or pattern");return g(n,e,{query:s.query,glob:s.glob,pattern:s.pattern,limit:s.limit,contentType:s.content_type,cwd:s.cwd})}case"check":{const s=Ee.parse(t.args);return m({files:s.files,cwd:s.cwd,skipTypes:s.skip_types,skipLint:s.skip_lint})}default:throw new Error(`Unsupported batch operation type: ${t.type}`)}}async function Te(t,n,e){const s=e.limit??5,o={limit:s,minScore:e.min_score??.25,contentType:e.content_type,origin:e.origin,category:e.category,tags:e.tags},i=t.embedQuery?.bind(t)??t.embed.bind(t);if(e.search_mode==="keyword")return(await n.ftsSearch(e.query,o)).slice(0,s);const a=await i(e.query);if(e.search_mode==="semantic")return n.search(a,o);const[l,c]=await Promise.all([n.search(a,{...o,limit:s*2}),n.ftsSearch(e.query,{...o,limit:s*2})]);return qe(l,c).slice(0,s)}function qe(t,n,e=60){const s=new Map;for(let o=0;o<t.length;o++){const i=t[o];s.set(i.record.id,{record:i.record,score:1/(e+o+1)})}for(let o=0;o<n.length;o++){const i=n[o],a=s.get(i.record.id);if(a){a.score+=1/(e+o+1);continue}s.set(i.record.id,{record:i.record,score:1/(e+o+1)})}return[...s.values()].sort((o,i)=>i.score-o.score)}function Oe(t){const n=[`Symbol: ${t.name}`];if(t.definedIn?n.push(`Defined in: ${t.definedIn.path}:${t.definedIn.line} (${t.definedIn.kind})`):n.push("Defined in: not found"),n.push("","Imported by:"),t.importedBy.length===0)n.push("  none");else for(const e of t.importedBy)n.push(`  - ${e.path}:${e.line} ${e.importStatement}`);if(n.push("","Referenced in:"),t.referencedIn.length===0)n.push("  none");else for(const e of t.referencedIn)n.push(`  - ${e.path}:${e.line} ${e.context}`);return n.join(`
+`)}function Me(t){const n=[`Vitest run: ${t.passed?"passed":"failed"}`,`Duration: ${t.durationMs}ms`,`Passed: ${t.summary.passed}`,`Failed: ${t.summary.failed}`,`Skipped: ${t.summary.skipped}`];t.summary.suites!==void 0&&n.push(`Suites: ${t.summary.suites}`);const e=t.summary.tests.filter(s=>s.status==="fail");if(e.length>0){n.push("","Failed tests:");for(const s of e)n.push(`- ${s.name}${s.file?` (${s.file})`:""}`),s.error&&n.push(`  ${s.error}`)}return n.join(`
+`)}function Ne(t){const n=[`Branch: ${t.branch}`,`Staged: ${t.status.staged.length}`,...t.status.staged.map(e=>`  - ${e}`),`Modified: ${t.status.modified.length}`,...t.status.modified.map(e=>`  - ${e}`),`Untracked: ${t.status.untracked.length}`,...t.status.untracked.map(e=>`  - ${e}`),"","Recent commits:"];if(t.recentCommits.length===0)n.push("  none");else for(const e of t.recentCommits)n.push(`  - ${e.hash} ${e.message}`),n.push(`    ${e.author} @ ${e.date}`);return t.diff&&n.push("","Diff stat:",t.diff),n.join(`
+`)}function _e(t){if(t.length===0)return"No diff files found.";const n=[];for(const e of t){const s=e.oldPath?` (from ${e.oldPath})`:"";n.push(`${e.path}${s} [${e.status}] +${e.additions} -${e.deletions} (${e.hunks.length} hunks)`);for(const o of e.hunks){const i=o.header?` ${o.header}`:"";n.push(`  @@ -${o.oldStart},${o.oldLines} +${o.newStart},${o.newLines} @@${i}`)}}return n.join(`
+`)}function Re(t){return[t.path,`Language: ${t.language}`,`Lines: ${t.lines}`,`Estimated tokens: ~${t.estimatedTokens}`,"",`Imports (${t.imports.length}):`,...p(t.imports),"",`Exports (${t.exports.length}):`,...p(t.exports),"",`Functions (${t.functions.length}):`,...p(t.functions.map(e=>`${e.name} @ line ${e.line}${e.exported?" [exported]":""}`)),"",`Classes (${t.classes.length}):`,...p(t.classes.map(e=>`${e.name} @ line ${e.line}${e.exported?" [exported]":""}`)),"",`Interfaces (${t.interfaces.length}):`,...p(t.interfaces.map(e=>`${e.name} @ line ${e.line}`)),"",`Types (${t.types.length}):`,...p(t.types.map(e=>`${e.name} @ line ${e.line}`))].join(`
+`)}function f(t){const n=[t.id,`Label: ${t.label}`,`Created: ${t.createdAt}`];if(t.notes&&n.push(`Notes: ${t.notes}`),t.files?.length){n.push(`Files: ${t.files.length}`);for(const e of t.files)n.push(`  - ${e}`)}return n.push("","Data:",JSON.stringify(t.data,null,2)),n.join(`
+`)}function p(t){return t.length===0?["  none"]:t.map(n=>`  - ${n}`)}function Ie(t){const n=t.trim();if(!n)return"";try{return JSON.parse(n)}catch{return t}}function Je(t){const n=t?.trim();if(!n)return{};const e=JSON.parse(n);if(!e||typeof e!="object"||Array.isArray(e))throw new Error("data must be a JSON object string");return e}function dt(t){t.registerTool("web_fetch",{description:"PREFERRED web fetcher \u2014 fetch any URL and convert to LLM-optimized markdown. Supports CSS selectors, 4 output modes (markdown/raw/links/outline), smart paragraph-boundary truncation. Strips scripts/styles/nav automatically.",inputSchema:{url:r.string().url().describe("URL to fetch (http/https only)"),mode:r.enum(["markdown","raw","links","outline"]).default("markdown").describe("Output mode: markdown (clean content), raw (HTML), links (extracted URLs), outline (heading hierarchy)"),selector:r.string().optional().describe("CSS selector to extract a specific element instead of auto-detecting main content"),max_length:r.number().min(500).max(1e5).default(15e3).describe("Max characters in output \u2014 truncates at paragraph boundaries"),include_metadata:r.boolean().default(!0).describe("Include page title, description, and URL as a header"),include_links:r.boolean().default(!1).describe("Append extracted links list at the end"),include_images:r.boolean().default(!1).describe("Include image alt texts inline"),timeout:r.number().min(1e3).max(6e4).default(15e3).describe("Request timeout in milliseconds")}},async({url:n,mode:e,selector:s,max_length:o,include_metadata:i,include_links:a,include_images:l,timeout:c})=>{try{const u=await Se({url:n,mode:e,selector:s,maxLength:o,includeMetadata:i,includeLinks:a,includeImages:l,timeout:c}),d=[`## ${u.title||"Web Page"}`,"",u.content];return u.truncated&&d.push("",`_Original length: ${u.originalLength.toLocaleString()} chars_`),d.push("","---","_Next: Use `remember` to save key findings, or `web_fetch` with a `selector` to extract a specific section._"),{content:[{type:"text",text:d.join(`
+`)}]}}catch(u){return{content:[{type:"text",text:`Web fetch failed: ${u.message}`}],isError:!0}}})}export{Ke as registerBatchTool,We as registerCheckTool,Ze as registerCheckpointTool,Xe as registerCodemodTool,Le as registerCompactTool,et as registerDataTransformTool,st as registerDeadSymbolsTool,it as registerDelegateTool,He as registerDiffParseTool,Be as registerEvalTool,Ye as registerFileSummaryTool,rt as registerFindExamplesTool,De as registerFindTool,Qe as registerGitContextTool,ct as registerHealthTool,at as registerLaneTool,Ae as registerParseOutputTool,nt as registerProcessTool,lt as registerQueueTool,Ve as registerRenameTool,Fe as registerScopeMapTool,Ge as registerStashTool,Ue as registerSymbolTool,ze as registerTestRunTool,tt as registerTraceTool,ot as registerWatchTool,dt as registerWebFetchTool,Pe as registerWorksetTool};