@akira-tl/forgerelay 0.3.6 → 0.4.0

package/dist/workspaces.js

@@ -11,6 +11,7 @@ import { loadLocalAgentProfiles, } from "./local-agent-profiles.js";
 const WORKSPACE_STALE_REMINDER_MS = 2 * 24 * 60 * 60 * 1_000;
 const WORKSPACE_SESSION_IDLE_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
 const WORKSPACE_GC_INTERVAL_MS = 60 * 60 * 1_000;
+const INITIAL_INSTRUCTION_DISCOVERY_DEPTH = 1;
 export class WorkspaceRegistry {
     config;
     store;
@@ -24,6 +25,9 @@ export class WorkspaceRegistry {
         this.hooks = new HookRunner(config.hooks, config.logging);
         this.pruneIdleWorkspaceSessions(new Set(), true);
     }
+    get cachedWorkspaceCount() {
+        return this.workspaces.size;
+    }
     async openWorkspace(input, openOptions = {}) {
         this.pruneIdleWorkspaceSessions(openOptions.protectedWorkspaceIds ?? new Set());
         const workspaceInput = typeof input === "string" ? { path: input } : input;
@@ -631,8 +635,11 @@ export class WorkspaceRegistry {
         Object.assign(workspace, this.loadSkillsForWorkspace(workspace.root));
         workspace.capabilityGuides = loadCapabilityGuides(this.config);
         workspace.agentProfiles = await loadLocalAgentProfiles(this.config, workspace.root);
-        const agentsFiles = await this.loadInitialAgentsFiles(workspace.root);
-        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace.root, agentsFiles);
+        workspace.scannedInstructionDirs.clear();
+        workspace.knownInstructionPathsByDir.clear();
+        workspace.loadedInstructionRealPaths.clear();
+        const agentsFiles = await this.loadInitialAgentsFiles(workspace);
+        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace, agentsFiles);
         const contextFingerprint = bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles);
         return {
             workspace,
@@ -686,6 +693,9 @@ export class WorkspaceRegistry {
             agentProfiles: [],
             activatedSkillDirs: new Set(),
             activatedCapabilityGuideDirs: new Set(),
+            scannedInstructionDirs: new Set(),
+            knownInstructionPathsByDir: new Map(),
+            loadedInstructionRealPaths: new Set(),
         };
         if (touch)
             this.store?.touchSession(session.id);
@@ -782,6 +792,9 @@ export class WorkspaceRegistry {
             agentProfiles: await loadLocalAgentProfiles(this.config, input.root),
             activatedSkillDirs: new Set(),
             activatedCapabilityGuideDirs: new Set(),
+            scannedInstructionDirs: new Set(),
+            knownInstructionPathsByDir: new Map(),
+            loadedInstructionRealPaths: new Set(),
         };
         this.store?.createSession({
             id: workspace.id,
@@ -807,8 +820,8 @@ export class WorkspaceRegistry {
                 targetBranch: workspace.worktree?.targetBranch,
             },
         });
-        const agentsFiles = await this.loadInitialAgentsFiles(workspace.root);
-        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace.root, agentsFiles);
+        const agentsFiles = await this.loadInitialAgentsFiles(workspace);
+        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace, agentsFiles);
         const contextFingerprint = bootstrapContextFingerprint(workspace, agentsFiles, availableAgentsFiles);
         return {
             workspace,
@@ -837,11 +850,9 @@ export class WorkspaceRegistry {
         }
         return assertAllowedPath(root, this.config.allowedRoots);
     }
-    async loadInitialAgentsFiles(root) {
-        const resolvedRoot = (await tryRealpath(root)) ?? root;
+    async loadInitialAgentsFiles(workspace) {
         const systemInstructionsPath = resolve(this.config.systemInstructionsPath);
         const loadedFiles = [];
-        const loadedRealPaths = new Set();
         const systemInstructions = await readSystemInstructions(systemInstructionsPath);
         const systemInstructionsRealPath = await tryRealpath(systemInstructionsPath);
         if (systemInstructions !== undefined) {
@@ -849,52 +860,125 @@ export class WorkspaceRegistry {
                 path: systemInstructionsPath,
                 content: systemInstructions,
             });
-            if (systemInstructionsRealPath)
-                loadedRealPaths.add(systemInstructionsRealPath);
-        }
-        for (const fileName of CONTEXT_FILE_NAMES) {
-            const path = join(root, fileName);
-            const content = await readResolvedProjectContextFile(path, resolvedRoot);
-            if (content === undefined)
-                continue;
-            const realPath = await tryRealpath(path);
-            if (realPath && loadedRealPaths.has(realPath))
-                continue;
-            loadedFiles.push({
-                path,
-                content,
-            });
-            if (realPath)
-                loadedRealPaths.add(realPath);
+            if (systemInstructionsRealPath) {
+                workspace.loadedInstructionRealPaths.add(systemInstructionsRealPath);
+            }
         }
+        await this.discoverInstructionTree(workspace, workspace.root, INITIAL_INSTRUCTION_DISCOVERY_DEPTH);
+        loadedFiles.push(...await this.loadKnownInstructionsInDirectory(workspace, workspace.root));
         return loadedFiles;
     }
-    async findAvailableAgentsFiles(root, loadedFiles) {
+    async findAvailableAgentsFiles(workspace, loadedFiles) {
         const loadedPaths = new Set(loadedFiles.map((file) => resolve(file.path)));
-        const loadedRealPaths = new Set();
-        for (const file of loadedFiles) {
-            const realPath = await tryRealpath(file.path);
-            if (realPath)
-                loadedRealPaths.add(realPath);
-        }
         const discovered = [];
-        const agentDir = resolve(this.config.agentDir);
-        await walkWorkspace(root, async (path, entry) => {
-            if (isPathInsideRoot(path, agentDir))
-                return;
-            if (!entry.isFile())
-                return;
-            if (!CONTEXT_FILE_NAMES.has(entry.name))
-                return;
-            if (loadedPaths.has(path))
-                return;
-            const realPath = await tryRealpath(path);
-            if (realPath && loadedRealPaths.has(realPath))
-                return;
-            discovered.push({ path });
-        });
+        for (const paths of workspace.knownInstructionPathsByDir.values()) {
+            for (const path of paths) {
+                if (loadedPaths.has(path))
+                    continue;
+                const realPath = await tryRealpath(path);
+                if (realPath && workspace.loadedInstructionRealPaths.has(realPath))
+                    continue;
+                discovered.push({ path });
+            }
+        }
         return discovered.sort((a, b) => a.path.localeCompare(b.path));
     }
+    async discoverPathInstructions(workspace, inputPath) {
+        const absolutePath = resolve(inputPath);
+        if (!isPathInsideRoot(absolutePath, workspace.root))
+            return [];
+        const targetDirectory = dirname(absolutePath);
+        const relationship = relative(workspace.root, targetDirectory);
+        if (relationship === ".." ||
+            relationship.startsWith(`..${sep}`) ||
+            resolve(targetDirectory) === resolve(this.config.agentDir) ||
+            isPathInsideRoot(targetDirectory, resolve(this.config.agentDir))) {
+            return [];
+        }
+        const directories = [resolve(workspace.root)];
+        if (relationship) {
+            let current = resolve(workspace.root);
+            for (const segment of relationship.split(sep).filter(Boolean)) {
+                if (SKIPPED_CONTEXT_DIRS.has(segment))
+                    break;
+                current = join(current, segment);
+                directories.push(current);
+            }
+        }
+        const loaded = [];
+        for (const directory of directories) {
+            await this.discoverInstructionTree(workspace, directory, 0);
+            loaded.push(...await this.loadKnownInstructionsInDirectory(workspace, directory));
+        }
+        return loaded;
+    }
+    async discoverInstructionTree(workspace, directory, remainingDepth) {
+        const resolvedDirectory = resolve(directory);
+        if (workspace.scannedInstructionDirs.has(resolvedDirectory))
+            return;
+        workspace.scannedInstructionDirs.add(resolvedDirectory);
+        if (resolvedDirectory !== resolve(workspace.root) &&
+            isPathInsideRoot(resolvedDirectory, resolve(this.config.agentDir))) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await opendir(resolvedDirectory);
+        }
+        catch {
+            return;
+        }
+        const instructionPaths = [];
+        const childDirectories = [];
+        for await (const entry of entries) {
+            const path = join(resolvedDirectory, entry.name);
+            if (entry.isFile() && CONTEXT_FILE_NAMES.has(entry.name)) {
+                instructionPaths.push(path);
+                continue;
+            }
+            if (remainingDepth > 0 &&
+                entry.isDirectory() &&
+                !SKIPPED_CONTEXT_DIRS.has(entry.name)) {
+                childDirectories.push(path);
+            }
+        }
+        workspace.knownInstructionPathsByDir.set(resolvedDirectory, instructionPaths.sort((left, right) => left.localeCompare(right)));
+        if (remainingDepth <= 0)
+            return;
+        for (const childDirectory of childDirectories) {
+            await this.discoverInstructionTree(workspace, childDirectory, remainingDepth - 1);
+        }
+    }
+    async loadKnownInstructionsInDirectory(workspace, directory) {
+        const resolvedDirectory = resolve(directory);
+        const paths = workspace.knownInstructionPathsByDir.get(resolvedDirectory) ?? [];
+        const loaded = [];
+        const resolvedRoot = (await tryRealpath(workspace.root)) ?? resolve(workspace.root);
+        const realDirectory = (await tryRealpath(resolvedDirectory)) ?? resolvedDirectory;
+        for (const path of paths) {
+            const realPath = await tryRealpath(path);
+            if (!realPath)
+                continue;
+            if (!isPathInsideRoot(realPath, resolvedRoot))
+                continue;
+            if (dirname(realPath) !== realDirectory)
+                continue;
+            if (workspace.loadedInstructionRealPaths.has(realPath))
+                continue;
+            let content;
+            try {
+                content = await readFile(realPath, "utf8");
+            }
+            catch (error) {
+                if (isErrnoException(error) && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+                    continue;
+                throw error;
+            }
+            workspace.loadedInstructionRealPaths.add(realPath);
+            loaded.push({ path, content });
+        }
+        return loaded;
+    }
 }
 function resolveBootstrapContextVisibility(mode, contextAlreadyDelivered) {
     if (mode === "full")
@@ -998,9 +1082,6 @@ export function formatAgentsPath(path, workspaceRoot) {
     }
     return relationship.split(sep).join("/");
 }
-function isProjectRootInstructionPath(path, root) {
-    return isPathInsideRoot(path, root) && dirname(path) === root;
-}
 async function readSystemInstructions(path) {
     try {
         return await readFile(path, "utf8");
@@ -1012,20 +1093,6 @@ async function readSystemInstructions(path) {
         throw error;
     }
 }
-async function readResolvedProjectContextFile(path, root) {
-    try {
-        const resolvedPath = await realpath(path);
-        if (!isProjectRootInstructionPath(resolvedPath, root))
-            return undefined;
-        return await readFile(resolvedPath, "utf8");
-    }
-    catch (error) {
-        if (isErrnoException(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
-            return undefined;
-        }
-        throw error;
-    }
-}
 async function tryRealpath(path) {
     try {
         return await realpath(path);
@@ -1034,25 +1101,6 @@ async function tryRealpath(path) {
         return undefined;
     }
 }
-async function walkWorkspace(directory, visit) {
-    let entries;
-    try {
-        entries = await opendir(directory);
-    }
-    catch {
-        return;
-    }
-    for await (const entry of entries) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            if (!SKIPPED_CONTEXT_DIRS.has(entry.name)) {
-                await walkWorkspace(path, visit);
-            }
-            continue;
-        }
-        await visit(path, entry);
-    }
-}
 function isErrnoException(error) {
     return error instanceof Error && "code" in error;
 }

package/docs/chatgpt-coding-workflow.md

@@ -157,10 +157,16 @@ CLAUDE.md
 CLAUDE.MD
 ```
 
-Nested project instruction files are returned as available paths rather than all
-being injected eagerly. Read the relevant nested file before working under that path.
-`FORGERELAY_AGENT_DIR` is not an instruction source; it remains only a compatibility
-skill-discovery path.
+To keep broad workspaces such as `~` fast, initial nested-instruction discovery is
+bounded to direct child directories instead of recursively walking the whole tree.
+Deeper `AGENTS.md` / `CLAUDE.md` files are discovered lazily along a path the first
+time the Agent accesses it, and already-scanned directories are cached for the life
+of that workspace handle. A `read` result carries any newly discovered local
+instructions before the requested file content. Side-effecting file tools and shell
+commands discover instructions before execution; if new local instructions are
+found, ForgeRelay returns them and requires the Agent to retry, so the side effect
+does not occur before the relevant instructions are known. `FORGERELAY_AGENT_DIR`
+is not an instruction source; it remains only a compatibility skill-discovery path.
 
 ## MCP capability loading
 

package/docs/configuration.md

@@ -151,6 +151,68 @@ snapshot, treat that as stale Host MCP metadata: reconnect/refresh the integrati
 or use a Host context that reloads `tools/list`. The ForgeRelay process cannot
 force a Host to invalidate its cached schema.
 
+### LSP code intelligence
+
+ForgeRelay advertises `code.intelligence` through the Capability Gateway; it does
+not add language-specific top-level MCP tools. ForgeRelay 0.4.0 supports the
+`definition` operation. Language Servers are external dependencies: ForgeRelay may
+discover an executable already installed on the machine, but it never downloads or
+installs one automatically.
+
+Effective Language-server definitions resolve in this order:
+
+1. project configuration in `.forgerelay/language-servers.json`;
+2. global definitions from the `languageServers` object in
+   `~/.forgerelay/config.json`;
+3. built-in discovery for known executables.
+
+A project configuration file is an object keyed by definition name. Definitions
+use structured process launch and never go through a shell:
+
+```json
+{
+  "typescript": {
+    "command": "typescript-language-server",
+    "args": ["--stdio"],
+    "env": {},
+    "languages": ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    "extensions": [".ts", ".tsx", ".js", ".jsx"],
+    "languageIdByExtension": {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact"
+    },
+    "projectMarkers": ["tsconfig.json", "jsconfig.json"]
+  }
+}
+```
+
+Global configuration uses the same definition shape under `languageServers`:
+
+```json
+{
+  "languageServers": {
+    "typescript": {
+      "command": "/absolute/path/to/typescript-language-server",
+      "args": ["--stdio"]
+    }
+  }
+}
+```
+
+Explicit configuration can set `"enabled": false` to suppress the matching
+built-in definition. Project values override global values, and both override
+built-in defaults. ForgeRelay resolves a Language project by walking ancestors of
+the requested source file according to that definition's `projectMarkers`; it does
+not recursively scan the Workspace.
+
+Code-intelligence input positions are 1-based line and 1-based Unicode code-point
+column values. The Workspace filesystem is the only v1 document source of truth.
+Definition results may point outside the Workspace and are then marked
+`external: true`; this is informational only and does not expand allowed roots or
+file-tool authority.
+
 `rename` is the canonical move/rename primitive for files and directories; there
 is no separate `move` MCP tool.
 
@@ -193,13 +255,24 @@ files. For a managed-worktree-backed workspace, `close_workspace` requires
 `commitMessage` and runs the existing safe worktree finalize lifecycle: close Hooks,
 commit when needed, fast-forward-only integration, cleanup, and alias invalidation.
 
+Hot workspace/session activity timestamps are coalesced in memory and flushed to the
+SQLite state database in a transaction at most every five minutes; normal shutdown
+performs a final explicit flush. Reads within the running ForgeRelay process see the
+latest in-memory timestamps immediately. Workspace creation, close/status changes,
+context-delivery checkpoints, and other semantic state transitions remain immediate
+persistent writes. A hard process crash may therefore lose only the most recent
+activity timestamp window, not the existence or closed/open state of a workspace.
+
 Regular `bash` has no execution-timeout input. `action="run"` (the default) waits
 in the foreground for at most 300 seconds; if the process is still alive, the
 result contains `running: true` and a canonical `processId`. Reuse the same `bash`
 with `action="process"` to poll/wait, send `input`, resize a PTY, or set
 `interrupt:true`; each wait can be up to 300 seconds. ForgeRelay does not kill a
 process merely because a wait window expires. Completed background processes are
-delivered once with a later tool result for the same logical workspace ID.
+delivered once with a later tool result for the same logical workspace ID. An
+unconsumed completed-process notice is retained for at most five minutes, and
+ForgeRelay also bounds active and completed process counts so repeated background
+commands cannot grow server memory without limit.
 
 Codex mode retains `write_stdin` only as an experimental compatibility adapter;
 regular Agent workflows should use the single `bash` process lifecycle.
@@ -348,8 +421,12 @@ Arrays or empty values are not accepted. Symbolic links are followed, so the
 runtime entry may point at a canonical source elsewhere on disk.
 
 Project-root `AGENTS.md` / `CLAUDE.md` files remain project context and are
-loaded separately. `FORGERELAY_AGENT_DIR` does not select a global instruction
-file; it remains a compatibility path for Agent Skills.
+loaded separately. Initial nested-instruction discovery checks only direct child
+directories; deeper instruction files are discovered lazily when a workspace path
+is first accessed. Reads surface newly discovered instructions inline, while
+side-effecting file/shell operations stop before execution and require a retry if
+that access discovers new local instructions. `FORGERELAY_AGENT_DIR` does not
+select a global instruction file; it remains a compatibility path for Agent Skills.
 
 ## Skills and subagents
 

package/docs/roadmap.md

@@ -183,6 +183,17 @@ capability
 - inventory 区分持久化 `status` 与派生 `state`：`status="active"` 表示尚未显式关闭，`state` 再区分 active、stale、invalid 与 closed；missing root 或外部删除的 managed worktree 可以保持可诊断的 active record，同时显示为 invalid；
 - inventory 查看本身不刷新 workspace `lastUsedAt`，支持过滤与分页，并继续让现有 `close_workspace` 承担用户确认后的实际清理/finalize lifecycle。
 
+### 0.3.7 — 资源生命周期与 Workspace I/O 性能补丁
+
+0.3.7 处理长时间运行实例在高请求量、高输出 `bash`、大量 logical workspace 与宽根目录下的资源放大问题，不改变 canonical 9-tool surface：
+
+- completed background process 的 Agent 可消费状态最多保留 5 分钟；底层 ChildProcess/PTY handle 在退出时立即释放，completed notice 数量与 active process 数量都有硬上限，并缩小单 process 输出驻留预算；
+- 高输出 head/tail buffer 保留 Unicode code-point 语义，但不再通过 `Array.from(整段输出)` 构造巨型临时数组，降低 V8 heap 扩容与 GC 压力；
+- MCP transport registry 与 review checkpoint state 加入容量边界；正常 transport close/workspace close 仍立即释放，异常遗弃对象不能再无限累积；OAuth 过期 authorization code 也会主动淘汰；
+- `open_workspace` 的 instruction discovery 首轮只检查 root 与直接子目录，不再递归整棵 workspace。更深层 `AGENTS.md` / `CLAUDE.md` 在 Agent 首次访问对应路径时沿祖先目录惰性发现，并缓存已扫描目录；read 可直接携带新发现指令，write/edit/rename/delete/bash 等副作用调用则在执行前返回指令并要求重试；
+- Workspace SQLite 继续作为本地持久化真源，不引入 Redis/PostgreSQL/Docker。高频 session/conversation `lastUsedAt` touch 进入内存 write-behind cache，最多每 5 分钟事务批量 flush，normal shutdown 再显式 flush；create/close/status 等语义性状态仍同步持久化；
+- debug runtime telemetry 定期报告 RSS/heap、transport、process、workspace cache 与 review state 数量，为后续真实实例资源趋势提供可观测性。
+
 必要安全语义始终留在 Core tool interface、Capability contract 或自动 Hook report 中；渐进式披露不能成为隐藏权限、隐式 autonomous workflow 或绕过 allowed roots/auth 的机制。`rename` 继续作为文件和目录 move/rename 的统一 primitive。
 
 ## 0.4 — LSP code intelligence v1
@@ -214,6 +225,21 @@ Candidate servers include `typescript-language-server`/tsserver, Pyright,
 `rust-analyzer`, `gopls`, and `clangd`, but ForgeRelay should treat server
 commands/configuration as external dependencies.
 
+0.4 is delivered as independently published patch releases rather than one large
+0.4.0 batch. Every boundary must complete local acceptance, update release metadata,
+create and push its matching tag, pass cloud CI, publish npm and the GitHub Release,
+and verify publication before work begins on the next boundary:
+
+- **0.4.0** — Language-service foundation plus the complete `definition` tracer bullet;
+- **0.4.1** — hover/type information;
+- **0.4.2** — references and bounded semantic-location results;
+- **0.4.3** — hierarchical document symbols and bounded workspace symbols;
+- **0.4.4** — push/pull diagnostics and Diagnostic snapshots;
+- **0.4.5** — cancellation, deadlines, crash recovery/config invalidation, concurrency,
+  and full Language-service resource/lifecycle hardening;
+- **0.4.6** — optional real-server interoperability, cross-platform checks, fresh Host
+  acceptance, documentation, and final LSP v1 closure.
+
 ## 0.5 — First-class subagent MCP
 
 ForgeRelay already owns provider adapters and resumable local agent sessions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -42,7 +42,7 @@
     "debug:accept": "node scripts/debug/accept.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "tsx src/config.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",
@@ -79,6 +79,8 @@
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
     "semver": "^7.8.4",
+    "vscode-jsonrpc": "^9.0.1",
+    "vscode-languageserver-protocol": "^3.18.2",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },

package/scripts/debug/accept.mjs

@@ -244,6 +244,7 @@ try {
       "process.lifecycle",
       "hooks.lifecycle",
       "capability-guides.read",
+      "code.intelligence",
       ...(process.platform === "linux" ? ["artifact.native-download"] : []),
       "ui.mcp-app",
       "review.changes",
@@ -253,6 +254,7 @@ try {
   assert.deepEqual(capabilityCatalog.map((entry) => entry.name), [
     "hooks.check",
     "review.changes",
+    "code.intelligence",
     ...(process.platform === "linux" ? ["artifact.download"] : []),
   ]);
   assert.equal(capabilityCatalog[0].available, true);
@@ -323,6 +325,18 @@ try {
   assert.equal(describedCapability.isError, undefined);
   assert.equal(describedCapability.structuredContent.capability.guide.name, "lifecycle-hooks");
   assert.equal(describedCapability.structuredContent.capability.inputSchema.type, "object");
+  const describedCodeIntelligence = callTool(oauth.accessToken, sessionId, 88, "capability", {
+    workspaceId,
+    name: "code.intelligence",
+    action: "describe",
+  });
+  assert.equal(describedCodeIntelligence.isError, undefined);
+  assert.equal(describedCodeIntelligence.structuredContent.capability.guide.name, "code-intelligence");
+  assert.equal(describedCodeIntelligence.structuredContent.capability.inputSchema.type, "object");
+  assert.equal(
+    describedCodeIntelligence.structuredContent.capability.inputSchema.properties.operation.const,
+    "definition",
+  );
   if (process.platform === "linux") {
     const describedArtifact = callTool(oauth.accessToken, sessionId, 82, "capability", {
       workspaceId,
@@ -350,6 +364,7 @@ try {
     "artifacts-review",
     "host-integration",
     "shell-processes",
+    "code-intelligence",
   ]);
   const hooksGuide = callTool(oauth.accessToken, sessionId, 78, "read", {
     workspaceId,