dsh-plugin-codegraph-tree-sitter 0.5.3 → 0.6.1

package/lib/index.js

@@ -27,7 +27,7 @@
  * this package ships with.
  * @module dsh-plugin-codegraph-tree-sitter
  */
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { stat } from 'node:fs/promises';
 import { join, posix } from 'node:path';
@@ -146,6 +146,10 @@ export function apply(ctx, config) {
     // legitimately trigger another refresh. The map only keeps a burst of sessions opened at once from
     // queueing the same rebuild repeatedly; the freshness decision itself reads the status sidecar.
     const lastAutoRun = new Map();
+    // Roots whose background run is still executing. Kept apart from `lastAutoRun`, which is a time
+    // window: a first build can outlive the window, and two builds on one root would only race the same
+    // index files.
+    const autoIndexInFlight = new Set();
     // `agent/created` is typed by `@deepseek-ai/dsh-agent`'s module augmentation. Reading the event
     // through a local structural face keeps this package's host dependencies unchanged: it needs one
     // event name and one payload shape, not the whole agent package.
@@ -210,63 +214,88 @@ export function apply(ctx, config) {
         if (resolved.autoIndexOnSession) {
             // Registered inside this effect so the listener follows the plugin's lifetime: unloading the
             // plugin must stop new sessions from scheduling work this instance can no longer run.
-            yield agentEvents.on('agent/created', payload => autoIndexOnSession(ctx, resolved, lastAutoRun, payload));
+            yield agentEvents.on('agent/created', payload => autoIndexOnSession(ctx, resolved, lastAutoRun, autoIndexInFlight, payload, ensureWatching));
         }
         yield ctx.codegraph.registerIndexer(indexer);
     }, 'codegraph-tree-sitter');
 }
-/** Stable job kind of an automatic session-start index, used for retention and diagnostics. */
-const AUTO_INDEX_JOB_KIND = 'codegraph-index';
+/**
+ * Whether a directory is the harness's own home rather than a project checkout.
+ *
+ * `sessions/` and `profiles/` together are what makes it one: either alone is a plausible folder
+ * name inside an ordinary repository, and requiring both keeps a real workspace eligible. The check
+ * exists because a DSH home is by construction tens of thousands of files — indexing it can only
+ * ever hit the session-start size guard, so queueing the job produces a failure and nothing else.
+ * @param root - the absolute workspace path.
+ * @returns true when the directory holds the harness's own state.
+ */
+function isHarnessHome(root) {
+    return existsSync(join(root, 'sessions')) && existsSync(join(root, 'profiles'));
+}
 /**
  * Index a new session's workspace in the background — when nothing has indexed it yet, or when what
  * is there has gone stale.
  *
  * Runs synchronously inside `agent/created` dispatch, so it must never block or throw: it only decides
- * whether a build is warranted and hands one to the host's job registry. A synchronous build here
- * would stall agent creation for the length of a parse, which is why a composition without background
- * jobs does nothing instead.
+ * whether a build is warranted and starts one in the background. A synchronous build here would stall
+ * agent creation for the length of a parse.
+ *
+ * The run deliberately does **not** go through the host's job registry. A registered job reports its
+ * settlement back to the owning agent: the host injects a completion notice into the next step and,
+ * under its default `wakeup` delivery, opens a turn on an idle one. An automatic index nobody asked
+ * for must not appear in the transcript or start a reply of its own, so this runs as a plain
+ * background promise. The explicit `codegraph_index` tool still registers a job — there a caller is
+ * waiting for the id.
  *
  * Refreshing a stale index is what restarts the file watcher after a host restart: watching only
  * begins once a successful index has established a baseline, so a workspace whose index is minutes
  * old would otherwise stay frozen at whatever the last process left behind.
- * @param ctx - the plugin context, consulted for the optional job registry.
+ * @param ctx - the plugin context.
  * @param config - the resolved plugin configuration, for the staleness threshold.
  * @param lastAutoRun - when this instance last started an automatic index for each root.
+ * @param autoIndexInFlight - roots whose background run is still executing, so a slow build cannot be
+ * started twice by sessions that open past the freshness window.
  * @param payload - the `agent/created` dispatch payload.
+ * @param ensureWatching - starts file watching for a workspace that is already current.
  */
-function autoIndexOnSession(ctx, config, lastAutoRun, payload) {
+function autoIndexOnSession(ctx, config, lastAutoRun, autoIndexInFlight, payload, ensureWatching) {
     try {
         const agent = payload.agent;
         const root = agent?.session?.header?.cwd;
         // No workspace means no root to claim: an agent created without a `cwd` has nothing to index.
         if (agent === undefined || !root)
             return;
+        // DSH's own home directory is not a code repository — `sessions/`, `attachments/`, the index
+        // databases and the installed plugins below it are a program's state. It is also tens of
+        // thousands of files, so every session opened there queued a job whose only possible outcome was
+        // the size guard failing. Skipping here keeps the job list honest: what is not a candidate never
+        // becomes a failure the user cannot act on.
+        if (isHarnessHome(root))
+            return;
         const now = Date.now();
         // A burst of sessions opened on one workspace must not queue the same rebuild repeatedly.
         const previous = lastAutoRun.get(root);
         if (previous !== undefined && now - previous < config.autoRefreshAfterMs)
             return;
+        // A build already running for this root is the one the window would have deduplicated had it been
+        // slow enough to straddle it; starting a second would only race the same index files.
+        if (autoIndexInFlight.has(root))
+            return;
         // A fresh sidecar means a recent run is already describing this workspace; an absent, unreadable
-        // or old one means the graph is missing or behind. Checked before the job lookup so a composition
-        // without background jobs never pays for the probe.
+        // or old one means the graph is missing or behind.
         const indexedAt = readStatusIndexedAt(root);
-        if (indexedAt !== undefined && now - indexedAt < config.autoRefreshAfterMs)
-            return;
-        // `ctx.get` rather than an `inject` entry: `jobs` is a host composition choice, and requiring it in
-        // `inject` would hide this whole indexer from a profile that runs no background jobs.
-        const jobs = ctx.get('jobs');
-        if (jobs === undefined)
+        if (indexedAt !== undefined && now - indexedAt < config.autoRefreshAfterMs) {
+            // The graph is current, so no build is warranted — but watching is process-local state and
+            // this is the first time this process has seen this workspace. Without this call, a restart
+            // followed by a session in an up-to-date workspace would leave it unwatched until the sidecar
+            // aged out, and every edit until then would silently not reach the graph.
+            ensureWatching(root);
             return;
-        jobs.start({
-            // The registry keys a job by its owning session id, not the agent object.
-            owner: agent.id,
-            kind: AUTO_INDEX_JOB_KIND,
-            label: `codegraph auto index ${root}`,
-            run: handle => runAutoIndexJob(ctx, root, config, handle),
-        });
-        // Marked only after the registry accepted the job, so a transient refusal leaves the workspace
-        // eligible for the next session that opens in it.
+        }
         lastAutoRun.set(root, now);
+        autoIndexInFlight.add(root);
+        // Never rejects: a lost index is a degradation, not an error the session can act on.
+        void runAutomaticIndex(ctx, root, config).finally(() => autoIndexInFlight.delete(root));
     }
     catch (error) {
         // The host treats a throwing listener as vetoing publication. Losing an index is a degradation,
@@ -274,6 +303,33 @@ function autoIndexOnSession(ctx, config, lastAutoRun, payload) {
         console.error(`codegraph-tree-sitter: automatic indexing for a new session failed: ${String(error)}`);
     }
 }
+/**
+ * Run one automatic index to completion, reporting a failure instead of propagating it.
+ *
+ * The size guard stays: parsing a workspace past `autoIndexMaxFiles` would exhaust the WASM heap and
+ * take the desktop down with it, and an automatic index is a convenience. Skipping it is a decision,
+ * not a failure, so it is logged once and the session continues untouched.
+ * @param ctx - the plugin context.
+ * @param root - absolute workspace path.
+ * @param config - the resolved plugin configuration.
+ */
+async function runAutomaticIndex(ctx, root, config) {
+    const controller = new AbortController();
+    try {
+        const oversized = await exceedsAutoIndexLimit(root, config, controller.signal);
+        if (oversized !== undefined) {
+            console.error(`codegraph-tree-sitter: skipped automatic indexing of ${root}: it holds at least ${String(oversized)} ` +
+                `candidate source files, past the ${String(config.autoIndexMaxFiles)}-file session-start limit. ` +
+                'Run codegraph_index yourself if you want a graph for it.');
+            return;
+        }
+        // A successful index is what starts file watching, inside `indexer.index`.
+        await ctx.codegraph.index(root, controller.signal);
+    }
+    catch (error) {
+        console.error(`codegraph-tree-sitter: automatic index for ${root} failed: ${String(error)}`);
+    }
+}
 /**
  * How many candidate source files `root` holds, when that is past the session-start limit.
  *
@@ -339,43 +395,6 @@ function readStatusIndexedAt(root) {
         return undefined;
     }
 }
-/**
- * The producer body of one automatic indexing job.
- *
- * Both halves of the host's job contract are mandatory: `cancel` aborts the run, and `done` settles
- * even on failure — a rejected `done` breaks the registry's bookkeeping and leaves the job looking
- * stuck forever.
- * @param ctx - the plugin context.
- * @param root - the workspace to index.
- * @param handle - the job's producer face, for the job's live log.
- * @returns the job's cancellation hook and settlement promise.
- */
-function runAutoIndexJob(ctx, root, config, handle) {
-    const controller = new AbortController();
-    const done = (async () => {
-        try {
-            const oversized = await exceedsAutoIndexLimit(root, config, controller.signal);
-            if (oversized !== undefined) {
-                // Declining here is the whole point of the check: parsing this workspace would exhaust the
-                // WASM heap and take the desktop down with it, and an automatic index is a convenience.
-                handle.append(`Skipped automatic indexing of ${root}: it holds at least ${String(oversized)} candidate ` +
-                    `source files, past the ${String(config.autoIndexMaxFiles)}-file session-start limit. ` +
-                    `Run codegraph_index yourself if you want a graph for it.\n`);
-                return { status: 'failed', detail: 'workspace too large for automatic indexing' };
-            }
-            const report = await ctx.codegraph.index(root, controller.signal);
-            handle.append(`Indexed ${root}: ${report.filesIndexed} files, ${report.nodeCount} symbols, ` +
-                `${report.edgeCount} relationships.\n`);
-            return { status: 'completed' };
-        }
-        catch (error) {
-            const message = String(error);
-            handle.append(`codegraph auto index failed for ${root}: ${message}\n`);
-            return { status: 'failed', detail: message };
-        }
-    })();
-    return { cancel: () => controller.abort(), done };
-}
 /**
  * Run one watch-triggered reindex. Always a full rebuild in this version — `runIndex` has no notion of
  * a file subset — so the watcher's own collected paths are not consulted here.

package/lib/rust-engine.d.ts

@@ -18,9 +18,9 @@ import type { FileExtraction } from './extract.ts';
 export declare const RUST_LANGUAGES: readonly string[];
 /**
  * Files handed to one addon call. The addon parses a batch across every core it can, so a large batch
- * is what makes it fast — but the call itself blocks the event loop for its whole duration, so the
- * batch is bounded to keep one call short enough that a watcher rebuild or a host request is not
- * stalled behind it.
+ * is what makes it fast. The call runs on libuv's thread pool (see {@link RustEngine}), so a batch no
+ * longer stalls the event loop; the bound now keeps one promise's lifetime — and the file text it
+ * holds in flight — reasonable, instead of capping a blocking call.
  */
 export declare const RUST_BATCH_SIZE = 200;
 /** One file as the addon takes it. */
@@ -39,11 +39,16 @@ export interface RustExtractInput {
 export interface RustEngine {
     /**
      * Extract definitions, calls, imports, and heritage for a batch of files.
+     *
+     * Answers a promise because the addon's body runs on libuv's thread pool: a synchronous native call
+     * blocked the host's event loop for the whole batch, which is what froze the desktop when automatic
+     * indexing ran inside the renderer. Callers `await` it; an older addon that still returns a string
+     * keeps working, because `await` on a non-promise is the value itself.
      * @param inputs - the files to extract; inputs in an unsupported language are silently skipped.
      * @param rulesJson - the `LanguageSpec` table, as JSON.
-     * @returns JSON of `{ results: [{ path, extraction }], supported: string[] }`.
+     * @returns a promise of JSON `{ results: [{ path, extraction }], supported: string[] }`.
      */
-    extractWorkspace(inputs: RustExtractInput[], rulesJson: string): string;
+    extractWorkspace(inputs: RustExtractInput[], rulesJson: string): Promise<string>;
 }
 /** Options for {@link loadRustEngine}. */
 export interface LoadRustEngineOptions {
@@ -53,14 +58,47 @@ export interface LoadRustEngineOptions {
      */
     readonly modulePath?: string;
 }
+/**
+ * Where the native package for this platform lives, when npm installed one.
+ *
+ * The addon ships as one optional dependency per platform (`optionalDependencies` in this package's
+ * manifest), so a `pnpm add` pulls exactly one binary — the one the running machine can `dlopen` —
+ * instead of every platform's. npm's `os`/`cpu` fields do the selection; a platform this project does
+ * not build for simply never installs one and the walk falls back to JS.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @returns the package name, or `undefined` for a platform with no published build.
+ */
+export declare function nativePackageName(platform: string, arch: string): string | undefined;
+/**
+ * Resolve this platform's optional native package to its `.node` entry, if it is installed.
+ *
+ * `require.resolve` is the only thing that knows where a dependency actually landed — pnpm's store,
+ * npm's flat tree, a hoisted profile — so the path is asked for rather than constructed. A missing
+ * package, or one whose `main` does not resolve, is `undefined`: that is the documented "no addon"
+ * answer, not an error.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @param resolve - module resolution, injectable so a test does not depend on what this machine has
+ *   installed.
+ * @returns the absolute path to the addon, or `undefined`.
+ */
+export declare function nativePackageModulePath(platform: string, arch: string, resolve?: (name: string) => string): string | undefined;
 /**
  * Every place the addon may live, most specific first.
  *
- * Two layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
- * published shape, and what a profile install gets when someone copies it in), while a repository
- * checkout builds it under `crates/indexer-rust/artifacts/`, three directories up from both `src/`
- * and `lib/` since those sit at the same depth. Trying both means one module works whether it was
- * installed or checked out.
+ * Three layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
+ * shape an older hand-copied install has), a repository checkout builds it under
+ * `crates/indexer-rust/artifacts/` (three directories up from both `src/` and `lib/`, which sit at the
+ * same depth), and an npm install carries it in the platform's optional dependency. Trying all three
+ * means one module works whether it was installed, copied in, or checked out.
+ * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
+ * @param fromPackage - this platform's optional-dependency path, or `undefined` when there is none.
+ * @returns absolute paths to try, in order.
+ */
+export declare function modulePathsFor(base: string, fromPackage: string | undefined): string[];
+/**
+ * The paths production should try, with this platform's optional package worked out for it.
  * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
  * @returns absolute paths to try, in order.
  */
@@ -89,7 +127,7 @@ export declare function loadRustEngine(options?: LoadRustEngineOptions): RustEng
  * @returns one extraction per path the addon answered for, or `undefined` when no answer can be
  *   trusted at all — no addon, a thrown call, or JSON that is not the documented shape.
  */
-export declare function extractWithRust(files: readonly RustExtractInput[], engine: RustEngine | undefined): Map<string, FileExtraction> | undefined;
+export declare function extractWithRust(files: readonly RustExtractInput[], engine: RustEngine | undefined): Promise<Map<string, FileExtraction> | undefined>;
 /**
  * Install a stand-in for the addon the walk resolves, or restore the real one.
  *

package/lib/rust-engine.js

@@ -20,30 +20,93 @@ import { LANGUAGE_TABLE } from "./languages.js";
 export const RUST_LANGUAGES = ['typescript', 'tsx', 'javascript', 'jsx'];
 /**
  * Files handed to one addon call. The addon parses a batch across every core it can, so a large batch
- * is what makes it fast — but the call itself blocks the event loop for its whole duration, so the
- * batch is bounded to keep one call short enough that a watcher rebuild or a host request is not
- * stalled behind it.
+ * is what makes it fast. The call runs on libuv's thread pool (see {@link RustEngine}), so a batch no
+ * longer stalls the event loop; the bound now keeps one promise's lifetime — and the file text it
+ * holds in flight — reasonable, instead of capping a blocking call.
  */
 export const RUST_BATCH_SIZE = 200;
 const require = createRequire(import.meta.url);
+/**
+ * Where the native package for this platform lives, when npm installed one.
+ *
+ * The addon ships as one optional dependency per platform (`optionalDependencies` in this package's
+ * manifest), so a `pnpm add` pulls exactly one binary — the one the running machine can `dlopen` —
+ * instead of every platform's. npm's `os`/`cpu` fields do the selection; a platform this project does
+ * not build for simply never installs one and the walk falls back to JS.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @returns the package name, or `undefined` for a platform with no published build.
+ */
+export function nativePackageName(platform, arch) {
+    const suffix = NATIVE_PACKAGES[`${platform}-${arch}`];
+    return suffix === undefined ? undefined : `dsh-plugin-codegraph-indexer-${suffix}`;
+}
+/**
+ * The suffix each published platform package carries, keyed by `platform-arch`.
+ *
+ * A suffix is not mechanical: the Linux builds are `-gnu` because a musl one would have to be a
+ * separate artifact, while Windows spells its ABI out. Keeping the table explicit is what stops this
+ * from silently computing a package name nobody publishes.
+ */
+const NATIVE_PACKAGES = {
+    'darwin-arm64': 'darwin-arm64',
+    'darwin-x64': 'darwin-x64',
+    'linux-x64': 'linux-x64-gnu',
+    'linux-arm64': 'linux-arm64-gnu',
+    'win32-x64': 'win32-x64-msvc',
+};
+/**
+ * Resolve this platform's optional native package to its `.node` entry, if it is installed.
+ *
+ * `require.resolve` is the only thing that knows where a dependency actually landed — pnpm's store,
+ * npm's flat tree, a hoisted profile — so the path is asked for rather than constructed. A missing
+ * package, or one whose `main` does not resolve, is `undefined`: that is the documented "no addon"
+ * answer, not an error.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @param resolve - module resolution, injectable so a test does not depend on what this machine has
+ *   installed.
+ * @returns the absolute path to the addon, or `undefined`.
+ */
+export function nativePackageModulePath(platform, arch, resolve = require.resolve) {
+    const name = nativePackageName(platform, arch);
+    if (name === undefined)
+        return undefined;
+    try {
+        return resolve(name);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Every place the addon may live, most specific first.
  *
- * Two layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
- * published shape, and what a profile install gets when someone copies it in), while a repository
- * checkout builds it under `crates/indexer-rust/artifacts/`, three directories up from both `src/`
- * and `lib/` since those sit at the same depth. Trying both means one module works whether it was
- * installed or checked out.
+ * Three layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
+ * shape an older hand-copied install has), a repository checkout builds it under
+ * `crates/indexer-rust/artifacts/` (three directories up from both `src/` and `lib/`, which sit at the
+ * same depth), and an npm install carries it in the platform's optional dependency. Trying all three
+ * means one module works whether it was installed, copied in, or checked out.
  * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
+ * @param fromPackage - this platform's optional-dependency path, or `undefined` when there is none.
  * @returns absolute paths to try, in order.
  */
-export function candidateModulePaths(base = import.meta.url) {
+export function modulePathsFor(base, fromPackage) {
     const artifact = `codegraph-indexer.${process.platform}-${process.arch}.node`;
     return [
         fileURLToPath(new URL(`../artifacts/${artifact}`, base)),
         fileURLToPath(new URL(`../../../crates/indexer-rust/artifacts/${artifact}`, base)),
+        ...fromPackage === undefined ? [] : [fromPackage],
     ];
 }
+/**
+ * The paths production should try, with this platform's optional package worked out for it.
+ * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
+ * @returns absolute paths to try, in order.
+ */
+export function candidateModulePaths(base = import.meta.url) {
+    return modulePathsFor(base, nativePackageModulePath(process.platform, process.arch));
+}
 /** Addons already loaded, keyed by path, so a test's stand-in never shadows the real artifact. */
 const loaded = new Map();
 /**
@@ -149,7 +212,7 @@ function rustRulesJson() {
  * @returns one extraction per path the addon answered for, or `undefined` when no answer can be
  *   trusted at all — no addon, a thrown call, or JSON that is not the documented shape.
  */
-export function extractWithRust(files, engine) {
+export async function extractWithRust(files, engine) {
     const supported = files.filter(file => RUST_LANGUAGES.includes(file.language));
     if (supported.length === 0)
         return new Map();
@@ -159,7 +222,10 @@ export function extractWithRust(files, engine) {
     try {
         for (let start = 0; start < supported.length; start += RUST_BATCH_SIZE) {
             const batch = supported.slice(start, start + RUST_BATCH_SIZE);
-            const answer = JSON.parse(engine.extractWorkspace(batch, rustRulesJson()));
+            // Awaited one batch at a time: the addon already parses a batch across every core, so
+            // overlapping batches would only compete for the same threads while multiplying the text held
+            // in flight.
+            const answer = JSON.parse(await engine.extractWorkspace(batch, rustRulesJson()));
             if (!isRecord(answer) || !Array.isArray(answer.results))
                 return undefined;
             for (const entry of answer.results) {

package/lib/schema.js

@@ -144,7 +144,12 @@ export async function writeGraph(databasePath, input) {
  */
 async function writeStatusFile(directory, status) {
     const target = join(directory, basename(INDEX_STATUS_RELATIVE_PATH));
-    const temp = `${target}.tmp`;
+    // Unique like the graph's own staging name, and for the same reason: two runs on one workspace are
+    // allowed to overlap (a session-start build and an explicit `codegraph_index`, or a watcher rebuild),
+    // and a shared fixed-name `.tmp` makes the loser's `rename` fail with ENOENT after the winner moved
+    // it — which turned a harmless duplicate run into a failed tool call. Last rename wins; both graphs
+    // are complete.
+    const temp = `${target}.tmp-${process.pid}-${randomUUID()}`;
     await writeFile(temp, JSON.stringify(status));
     await rename(temp, target);
 }

package/lib/walk.js

@@ -223,7 +223,7 @@ async function extractPending(pending, config, signal) {
     // those itself (`RUST_LANGUAGES`), so the walk never keeps a second copy of that list in sync.
     const rusted = engine === undefined
         ? new Map()
-        : extractWithRust(pending.map(toRustInput), engine) ?? new Map();
+        : await extractWithRust(pending.map(toRustInput), engine) ?? new Map();
     const extracted = new Array(pending.length);
     const fallback = [];
     for (const [index, file] of pending.entries()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-codegraph-tree-sitter",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "description": "Self-built code-graph indexer for DeepSeek Harness — parses a workspace with web-tree-sitter and writes schema version 4 to .codegraph/codegraph.db, the same on-disk format the codegraph CLI writes, so no external indexer is required",
   "keywords": [
     "dsh",
@@ -51,13 +51,20 @@
     "@deepseek-ai/schemastery": "^3.18.1",
     "tree-sitter-wasms": "^0.1.13",
     "web-tree-sitter": "^0.25.10",
-    "dsh-plugin-codegraph-service": "^0.5.3"
+    "dsh-plugin-codegraph-service": "^0.6.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",
     "@deepseek-ai/dsh-fs": ">=0.1.0-rc.6",
     "@deepseek-ai/dsh-invariants": ">=0.1.0-rc.6"
   },
+  "optionalDependencies": {
+    "dsh-plugin-codegraph-indexer-darwin-arm64": "0.6.1",
+    "dsh-plugin-codegraph-indexer-darwin-x64": "0.6.1",
+    "dsh-plugin-codegraph-indexer-linux-x64-gnu": "0.6.1",
+    "dsh-plugin-codegraph-indexer-linux-arm64-gnu": "0.6.1",
+    "dsh-plugin-codegraph-indexer-win32-x64-msvc": "0.6.1"
+  },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-invariants": "0.1.0-rc.6"