homegraph 1.6.2 → 1.6.4

package/CHANGELOG.md

@@ -10,6 +10,30 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
 
+## [1.6.4] - 2026-11-05
+
+### Improvements
+
+- Return and parameter types link to type nodes as `returns` / `type_of` edges (unique match only), so a type can be reverse-queried for methods that return or take it. Signature annotations are preferred; JSDoc `@returns` / `@param {Type}` fill gaps when the signature omits types. `nodes.return_type` is unchanged for chained-call inference (Spec 0066).
+
+### Fixes
+
+- Fresh index store-worker: the main DB connection is closed before the worker opens (and reopened after it drains), so ArkTS Phase-A writes and the worker no longer share the file. Stops `SQLITE_BUSY` / 100% CPU hangs on MEMORY or non-WAL backends. Reclaim clears and re-ATTACHes `ohos_api` (stale in-memory path after reopen caused `no such table: ohos_api.nodes`). Store flush failures now abort the feed backpressure loop instead of spinning (Spec 0065).
+- CLI `init` / `index` / `sync`: an explicit directory argument is used as-is. With no argument, the commands walk up from the cwd to the nearest `build-profile.json5` (Harmony project root), otherwise stay at cwd. They no longer adopt an ancestor `.homegraph` from a parent harness or monorepo, which could silently index the wrong tree (Spec 0061).
+- ArkTS: after a modular batch, orphan `.ets` files (outside PROJECT modules; still tree-sitter TypeScript fallback per Spec 0036) no longer fail with `Failed to get parser for language: typescript` on ArkUI-only trees. Indexing preloads the TypeScript WASM whenever `arkts` is in the language set, including on the main thread when parse workers are enabled (Spec 0062).
+- ArkUI `arkui-child` synthesis: when a PascalCase call name misses the name index (typical for framework `Column`/`Button`/`Text`), do not fall back to scanning every `struct`/`component`/`function`/`method` node — return no edge. Cuts large-repo resolveChild CPU (Spec 0063).
+- ArkTS ViewTree lazy method nodes (including `%AM*` handlers): `file_path` and `contains` parent always follow `getDeclaringArkFile()` / declaring class, not the ViewTree importer that first walked the nested tree — so anonymous callbacks no longer drift onto `MainPageView`-style hosts (Spec 0064).
+
+## [1.6.3] - 2026-10-22
+
+### Improvements
+
+- Release workflow jobs are split so a failed stage can be re-run alone: unit tests, CHANGELOG prepare, GitHub Release, npm publish, long registry verify, then OHOS API db packages.
+
+### Fixes
+
+- ArkTS: cross-file `imports` and `extends`/`implements` edges are no longer dropped during per-file persist. They ride the same `crossFileEdges` path as calls. Built-in ArkUI decorators (`@State`, `@Builder`, …) are not fuzzy-matched onto unrelated same-named symbols (Spec 0059).
+
 ## [1.6.2] - 2026-10-19
 
 ### New Features
@@ -305,3 +329,5 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 [1.6.0]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.0
 [1.6.1]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.1
 [1.6.2]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.2
+[1.6.3]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.3
+[1.6.4]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.4

package/dist/bin/homegraph.js

@@ -176,9 +176,12 @@ function main() {
     // Helper Functions
     // =============================================================================
     /**
-     * Resolve project path from argument or current directory
-     * Walks up parent directories to find nearest initialized HomeGraph project
-     * (must have .homegraph/homegraph.db, not just .homegraph/lessons.db)
+     * Resolve project path for *read* CLI commands (status, query, …).
+     * Walks up to the nearest initialized HomeGraph project (has homegraph.db).
+     *
+     * Mutating commands (`init` / `index` / `sync`) must NOT use this — they use
+     * {@link resolveCliMutatingProjectRoot} (Spec 0061) so an ancestor harness
+     * `.homegraph` cannot hijack a nested Harmony project.
      */
     function resolveProjectPath(pathArg) {
         const absolutePath = path.resolve(pathArg || process.cwd());
@@ -445,12 +448,13 @@ function main() {
      */
     program
         .command('init [path]')
-        .description('Initialize HomeGraph in a project directory and build the initial index')
+        .description('Initialize HomeGraph in a project directory and build the initial index (explicit path is literal; bare init uses nearest build-profile.json5)')
         .option('-i, --index', 'Deprecated: indexing now runs by default; flag accepted for backward compatibility')
         .option('-f, --force', 'Initialize even if the path looks like your home directory or a filesystem root')
         .option('-v, --verbose', 'Show detailed worker lifecycle and memory info')
         .action(async (pathArg, options) => {
-        const projectPath = path.resolve(pathArg || process.cwd());
+        // Spec 0061: explicit path is literal; bare init walks up to build-profile.json5.
+        const projectPath = (0, directory_1.resolveCliMutatingProjectRoot)(pathArg);
         const clack = await importESM('@clack/prompts');
         clack.intro('Initializing HomeGraph');
         try {
@@ -569,13 +573,14 @@ function main() {
      */
     program
         .command('index [path]')
-        .description('Rebuild the full index from scratch (same result as a fresh init)')
+        .description('Rebuild the full index from scratch (explicit path is literal; bare index uses nearest build-profile.json5)')
         .option('-f, --force', 'Index even if the path looks like your home directory or a filesystem root')
         .option('-q, --quiet', 'Suppress progress output')
         .option('-v, --verbose', 'Show detailed worker lifecycle and memory info')
         .option('--inplace', 'Index into the existing database without recreating it (MCP auto-init; DB may already be open by the parent)')
         .action(async (pathArg, options) => {
-        const projectPath = resolveProjectPath(pathArg);
+        // Spec 0061: do not adopt an ancestor .homegraph (harness hijack).
+        const projectPath = (0, directory_1.resolveCliMutatingProjectRoot)(pathArg);
         try {
             // Don't (re)index your home directory / a filesystem root (#845). --force
             // doubles as the override.
@@ -647,10 +652,11 @@ function main() {
      */
     program
         .command('sync [path]')
-        .description('Sync changes since last index')
+        .description('Sync changes since last index (explicit path is literal; bare sync uses nearest build-profile.json5)')
         .option('-q, --quiet', 'Suppress output (for git hooks)')
         .action(async (pathArg, options) => {
-        const projectPath = resolveProjectPath(pathArg);
+        // Spec 0061: same root rules as init/index.
+        const projectPath = (0, directory_1.resolveCliMutatingProjectRoot)(pathArg);
         try {
             if (!(0, directory_1.isInitialized)(projectPath)) {
                 if (!options.quiet) {

package/dist/db/index.d.ts

@@ -36,6 +36,11 @@ export declare class DatabaseConnection {
      * dead inode forever (#925). See `isReplacedOnDisk`.
      */
     private openedInode;
+    /**
+     * True after {@link closeForExclusiveWriter} until {@link reopenAfterExclusiveWriter}.
+     * The underlying handle is closed; callers must not use {@link getDb} in this window.
+     */
+    private releasedForExclusiveWriter;
     private constructor();
     /**
      * Initialize a new database at the given path
@@ -334,6 +339,22 @@ export declare class DatabaseConnection {
      * Check if the database connection is open
      */
     isOpen(): boolean;
+    /**
+     * Close this handle so another writer (fresh-index store-worker) can own the
+     * DB file exclusively. On-disk bulk-load state (dropped secondary indexes /
+     * missing FTS triggers) is preserved — do NOT use {@link open} to come back.
+     * Pair with {@link reopenAfterExclusiveWriter}. Spec 0065.
+     */
+    closeForExclusiveWriter(): void;
+    /**
+     * Re-open after {@link closeForExclusiveWriter}. Skips `open()` healers so a
+     * mid-`indexAll` bulk window stays open until `endBulk*`. When `fastInit` is
+     * set, restores MEMORY journal + OFF synchronous to match the pre-handoff
+     * fresh-index path. Spec 0065.
+     */
+    reopenAfterExclusiveWriter(opts: {
+        fastInit: boolean;
+    }): void;
     /**
      * True when the DB file at our path has been REPLACED on disk since we opened
      * it — a different inode now lives at the same path, so the fd we still hold

package/dist/db/index.js

@@ -124,6 +124,11 @@ class DatabaseConnection {
      * dead inode forever (#925). See `isReplacedOnDisk`.
      */
     openedInode;
+    /**
+     * True after {@link closeForExclusiveWriter} until {@link reopenAfterExclusiveWriter}.
+     * The underlying handle is closed; callers must not use {@link getDb} in this window.
+     */
+    releasedForExclusiveWriter = false;
     constructor(db, dbPath, backend) {
         this.db = db;
         this.dbPath = dbPath;
@@ -753,14 +758,65 @@ class DatabaseConnection {
      * Close the database connection
      */
     close() {
+        this.releasedForExclusiveWriter = false;
         this.db.close();
     }
     /**
      * Check if the database connection is open
      */
     isOpen() {
+        if (this.releasedForExclusiveWriter)
+            return false;
         return this.db.open;
     }
+    /**
+     * Close this handle so another writer (fresh-index store-worker) can own the
+     * DB file exclusively. On-disk bulk-load state (dropped secondary indexes /
+     * missing FTS triggers) is preserved — do NOT use {@link open} to come back.
+     * Pair with {@link reopenAfterExclusiveWriter}. Spec 0065.
+     */
+    closeForExclusiveWriter() {
+        if (this.releasedForExclusiveWriter)
+            return;
+        this.db.close();
+        this.releasedForExclusiveWriter = true;
+    }
+    /**
+     * Re-open after {@link closeForExclusiveWriter}. Skips `open()` healers so a
+     * mid-`indexAll` bulk window stays open until `endBulk*`. When `fastInit` is
+     * set, restores MEMORY journal + OFF synchronous to match the pre-handoff
+     * fresh-index path. Spec 0065.
+     */
+    reopenAfterExclusiveWriter(opts) {
+        if (!this.releasedForExclusiveWriter) {
+            throw new Error('reopenAfterExclusiveWriter: connection was not released for exclusive writer');
+        }
+        const { db, backend } = (0, sqlite_adapter_1.createDatabase)(this.dbPath);
+        // Mirror configureConnection essentials without healBulkNodeLoad / migrations.
+        db.pragma('busy_timeout = 5000');
+        db.pragma('foreign_keys = ON');
+        if (opts.fastInit) {
+            try {
+                db.pragma('journal_mode = MEMORY');
+                db.pragma('synchronous = OFF');
+            }
+            catch {
+                /* keep whatever the backend allows */
+            }
+        }
+        else {
+            db.pragma('journal_mode = WAL');
+            db.pragma('synchronous = NORMAL');
+        }
+        db.pragma('cache_size = -16000');
+        db.pragma('temp_store = MEMORY');
+        db.pragma('mmap_size = 0');
+        db.pragma(`journal_size_limit = ${exports.WAL_HEAL_THRESHOLD_BYTES}`);
+        this.db = db;
+        this.backend = backend;
+        this.openedInode = statInode(this.dbPath);
+        this.releasedForExclusiveWriter = false;
+    }
     /**
      * True when the DB file at our path has been REPLACED on disk since we opened
      * it — a different inode now lives at the same path, so the fd we still hold

package/dist/directory.d.ts

@@ -63,6 +63,23 @@ export declare function isInitialized(projectRoot: string): boolean;
  * The returned string is a human phrase that slots into "… looks like {reason}".
  */
 export declare function unsafeIndexRootReason(projectRoot: string): string | null;
+/**
+ * Walk up from `startPath` looking for a HarmonyOS project root
+ * (`build-profile.json5`). Returns null if none is found before the
+ * filesystem root. Spec 0061.
+ */
+export declare function findNearestHarmonyProjectRoot(startPath: string): string | null;
+/**
+ * Resolve the project root for CLI mutating commands (`init` / `index` / `sync`).
+ *
+ * - Explicit `pathArg` → `path.resolve(cwd, pathArg)` literally (no walk-up).
+ * - Omitted / empty → nearest ancestor (or cwd) with `build-profile.json5`,
+ *   else `cwd`. Never adopts an ancestor `.homegraph` that is not that root
+ *   (Spec 0061 — fixes parent-harness index hijack).
+ *
+ * `cwd` is injectable for tests; production callers omit it.
+ */
+export declare function resolveCliMutatingProjectRoot(pathArg?: string | null, cwd?: string): string;
 export declare function findNearestHomeGraphRoot(startPath: string, floor?: string): string | null;
 /**
  * Indexed sub-project roots beneath `root` (bounded breadth-first scan). For

package/dist/directory.js

@@ -44,6 +44,8 @@ exports.isHomeGraphDataDir = isHomeGraphDataDir;
 exports.getHomeGraphDir = getHomeGraphDir;
 exports.isInitialized = isInitialized;
 exports.unsafeIndexRootReason = unsafeIndexRootReason;
+exports.findNearestHarmonyProjectRoot = findNearestHarmonyProjectRoot;
+exports.resolveCliMutatingProjectRoot = resolveCliMutatingProjectRoot;
 exports.findNearestHomeGraphRoot = findNearestHomeGraphRoot;
 exports.findIndexedSubprojectRoots = findIndexedSubprojectRoots;
 exports.hasStructuralKeyword = hasStructuralKeyword;
@@ -183,6 +185,44 @@ function unsafeIndexRootReason(projectRoot) {
     }
     return null;
 }
+/**
+ * Walk up from `startPath` looking for a HarmonyOS project root
+ * (`build-profile.json5`). Returns null if none is found before the
+ * filesystem root. Spec 0061.
+ */
+function findNearestHarmonyProjectRoot(startPath) {
+    let current = path.resolve(startPath);
+    const fsRoot = path.parse(current).root;
+    while (true) {
+        if (fs.existsSync(path.join(current, 'build-profile.json5'))) {
+            return current;
+        }
+        if (current === fsRoot)
+            break;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+/**
+ * Resolve the project root for CLI mutating commands (`init` / `index` / `sync`).
+ *
+ * - Explicit `pathArg` → `path.resolve(cwd, pathArg)` literally (no walk-up).
+ * - Omitted / empty → nearest ancestor (or cwd) with `build-profile.json5`,
+ *   else `cwd`. Never adopts an ancestor `.homegraph` that is not that root
+ *   (Spec 0061 — fixes parent-harness index hijack).
+ *
+ * `cwd` is injectable for tests; production callers omit it.
+ */
+function resolveCliMutatingProjectRoot(pathArg, cwd = process.cwd()) {
+    const base = path.resolve(cwd);
+    if (pathArg !== undefined && pathArg !== null && String(pathArg).trim() !== '') {
+        return path.resolve(base, String(pathArg).trim());
+    }
+    return findNearestHarmonyProjectRoot(base) ?? base;
+}
 function findNearestHomeGraphRoot(startPath, floor) {
     // A floor (an MCP host's explicit --path / rootUri) bounds the walk: an
     // ancestor .homegraph above it must not be adopted — a stray ancestor index

package/dist/extraction/grammars.js

@@ -386,6 +386,13 @@ function expandGrammarLanguages(languages) {
     if (languages.some((l) => l === 'cfml')) {
         languages = [...languages, 'cfscript', 'cfquery'];
     }
+    // ArkTS has no WASM of its own. After a modular AA batch, packageless /
+    // forgotten-HAR .ets that never entered a PROJECT module fall through to
+    // TreeSitterExtractor(..., 'typescript') as a shallow symbol fallback — so
+    // the TS grammar must be loaded even when the index set is pure .ets.
+    if (languages.some((l) => l === 'arkts')) {
+        languages = [...languages, 'typescript'];
+    }
     return languages;
 }
 /**

package/dist/extraction/index.d.ts

@@ -196,6 +196,11 @@ export declare class ExtractionOrchestrator {
     indexAll(onProgress?: (progress: IndexProgress) => void, signal?: AbortSignal, verbose?: boolean, walBackpressure?: () => Promise<void> | null, storeWriterOpts?: {
         dbPath: string;
         fastInit: boolean;
+        /** Spec 0065: close main DB before worker open; reclaim after worker close. */
+        exclusiveHandoff?: {
+            release: () => void;
+            reclaim: () => void;
+        };
     } | null): Promise<IndexResult>;
     /**
      * Index specific files

package/dist/extraction/index.js

@@ -57,6 +57,7 @@ const child_process_1 = require("child_process");
 const tree_sitter_1 = require("./tree-sitter");
 const parse_pool_1 = require("./parse-pool");
 const store_writer_1 = require("./store-writer");
+const store_flush_guard_1 = require("./store-flush-guard");
 const cooperative_yield_1 = require("../resolution/cooperative-yield");
 const grammars_1 = require("./grammars");
 const project_config_1 = require("../project-config");
@@ -1464,6 +1465,7 @@ class ExtractionOrchestrator {
                 // advances (buffered items hold whole file contents, so this bound is
                 // load-bearing for memory).
                 while (nextSeq - nextToStore >= windowSize) {
+                    (0, store_flush_guard_1.throwIfStoreFlushFailed)(aborted, flushError);
                     if (inFlight.size > 0)
                         await Promise.race(inFlight);
                     else
@@ -1505,16 +1507,43 @@ class ExtractionOrchestrator {
                 });
                 windowSize = Math.max(4, pool.size * 2);
                 log(`Parse worker pool: ${poolSize} worker(s) (remaining files≈${remainingToParse})`);
+                // ArkTS extraction is in-process (requiresInProcessExtraction). Orphan
+                // .ets after the AA batch use TreeSitterExtractor('typescript') on this
+                // thread — workers loading TS wasm does not help the main isolate.
+                if (neededLanguages.includes('arkts')) {
+                    await (0, grammars_1.loadGrammarsForLanguages)(neededLanguages);
+                }
             }
             else {
                 await (0, grammars_1.loadGrammarsForLanguages)(neededLanguages);
             }
             const storeWorkerPath = path.join(__dirname, 'store-worker.js');
+            /** Spec 0065: true after exclusiveHandoff.release until matching reclaim. */
+            let storeHandoffReleased = false;
+            const reclaimStoreHandoff = () => {
+                if (!storeHandoffReleased)
+                    return;
+                storeHandoffReleased = false;
+                storeWriterOpts?.exclusiveHandoff?.reclaim();
+            };
             if (storeWriterOpts &&
                 process.env.HOMEGRAPH_NO_STORE_WORKER !== '1' &&
                 fs.existsSync(storeWorkerPath)) {
-                storeWriter = new store_writer_1.StoreWriter(storeWorkerPath, storeWriterOpts.dbPath, storeWriterOpts.fastInit);
-                log('Store writer thread active');
+                // Phase A (ArkTS / main-thread writes) is done; close the main connection
+                // before the worker opens its own — dual MEMORY/DELETE connections are
+                // what turn a transient SQLITE_BUSY into a hung index (Spec 0065).
+                if (storeWriterOpts.exclusiveHandoff) {
+                    storeWriterOpts.exclusiveHandoff.release();
+                    storeHandoffReleased = true;
+                }
+                try {
+                    storeWriter = new store_writer_1.StoreWriter(storeWorkerPath, storeWriterOpts.dbPath, storeWriterOpts.fastInit);
+                    log('Store writer thread active');
+                }
+                catch (err) {
+                    reclaimStoreHandoff();
+                    throw err;
+                }
             }
             // Parsing progress only after ArkTS batch (avoids false "Parsing - done").
             onProgress?.({
@@ -1523,135 +1552,152 @@ class ExtractionOrchestrator {
                 total,
             });
             await new Promise((resolve) => setImmediate(resolve));
-            for (let i = 0; i < files.length; i += FILE_IO_BATCH_SIZE) {
-                if (signal?.aborted) {
-                    aborted = true;
-                    break;
-                }
-                const batch = files.slice(i, i + FILE_IO_BATCH_SIZE);
-                // Read files in parallel (with path validation before any I/O)
-                const fileContents = await Promise.all(batch.map(async (fp) => {
-                    if ((0, arkts_1.isArkTSBatchPersisted)(fp)) {
-                        return {
-                            filePath: fp,
-                            content: null,
-                            stats: null,
-                            error: null,
-                            arktsBatchSkipped: true,
-                        };
-                    }
-                    try {
-                        // Indexing read: follow in-root symlinks the directory walk already
-                        // descended into (the `../` guard still applies) so files reached
-                        // via an in-root symlink-to-outside still index (#935).
-                        const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, fp, { allowSymlinkEscape: true });
-                        if (!fullPath) {
-                            (0, errors_1.logWarn)('Path traversal blocked in batch reader', { filePath: fp });
-                            return { filePath: fp, content: null, stats: null, error: new Error('Path traversal blocked') };
-                        }
-                        const content = await fsp.readFile(fullPath, 'utf-8');
-                        const stats = await fsp.stat(fullPath);
-                        return { filePath: fp, content, stats, error: null };
-                    }
-                    catch (err) {
-                        return { filePath: fp, content: null, stats: null, error: err };
-                    }
-                }));
-                // Dispatch each readable file into the bounded parse window; the window
-                // stores results on the main thread as they arrive.
-                for (const fileEntry of fileContents) {
-                    const { filePath, content, stats, error } = fileEntry;
-                    const arktsBatchSkipped = 'arktsBatchSkipped' in fileEntry && fileEntry.arktsBatchSkipped;
+            try {
+                for (let i = 0; i < files.length; i += FILE_IO_BATCH_SIZE) {
                     if (signal?.aborted) {
                         aborted = true;
                         break;
                     }
-                    if ((0, arkts_1.isArkTSBatchPersisted)(filePath) || arktsBatchSkipped) {
-                        processed++;
-                        filesIndexed++;
-                        onProgress?.({ phase: 'parsing', current: processed, total, currentFile: filePath });
-                        continue;
-                    }
-                    if (!(0, context_1.isArktsBatchRunning)()) {
-                        onProgress?.({
-                            phase: 'parsing',
-                            current: processed,
-                            total,
-                            currentFile: filePath,
-                        });
+                    const batch = files.slice(i, i + FILE_IO_BATCH_SIZE);
+                    // Read files in parallel (with path validation before any I/O)
+                    const fileContents = await Promise.all(batch.map(async (fp) => {
+                        if ((0, arkts_1.isArkTSBatchPersisted)(fp)) {
+                            return {
+                                filePath: fp,
+                                content: null,
+                                stats: null,
+                                error: null,
+                                arktsBatchSkipped: true,
+                            };
+                        }
+                        try {
+                            // Indexing read: follow in-root symlinks the directory walk already
+                            // descended into (the `../` guard still applies) so files reached
+                            // via an in-root symlink-to-outside still index (#935).
+                            const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, fp, { allowSymlinkEscape: true });
+                            if (!fullPath) {
+                                (0, errors_1.logWarn)('Path traversal blocked in batch reader', { filePath: fp });
+                                return { filePath: fp, content: null, stats: null, error: new Error('Path traversal blocked') };
+                            }
+                            const content = await fsp.readFile(fullPath, 'utf-8');
+                            const stats = await fsp.stat(fullPath);
+                            return { filePath: fp, content, stats, error: null };
+                        }
+                        catch (err) {
+                            return { filePath: fp, content: null, stats: null, error: err };
+                        }
+                    }));
+                    // Dispatch each readable file into the bounded parse window; the window
+                    // stores results on the main thread as they arrive.
+                    for (const fileEntry of fileContents) {
+                        const { filePath, content, stats, error } = fileEntry;
+                        const arktsBatchSkipped = 'arktsBatchSkipped' in fileEntry && fileEntry.arktsBatchSkipped;
+                        if (signal?.aborted) {
+                            aborted = true;
+                            break;
+                        }
+                        if ((0, arkts_1.isArkTSBatchPersisted)(filePath) || arktsBatchSkipped) {
+                            processed++;
+                            filesIndexed++;
+                            onProgress?.({ phase: 'parsing', current: processed, total, currentFile: filePath });
+                            continue;
+                        }
+                        if (!(0, context_1.isArktsBatchRunning)()) {
+                            onProgress?.({
+                                phase: 'parsing',
+                                current: processed,
+                                total,
+                                currentFile: filePath,
+                            });
+                        }
+                        if (error || content === null || stats === null) {
+                            processed++;
+                            filesErrored++;
+                            errors.push({
+                                message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+                                filePath,
+                                severity: 'error',
+                                code: 'read_error',
+                            });
+                            onProgress?.({ phase: 'parsing', current: processed, total });
+                            continue;
+                        }
+                        // Honour MAX_FILE_SIZE. Without this check, vendored generated
+                        // headers, minified bundles, and other multi-MB files get indexed,
+                        // wasting WASM heap and the worker recycle budget on inputs with no
+                        // useful symbols. The single-file extractFile path already enforces
+                        // this; the bulk path used to silently skip the check.
+                        if (stats.size > MAX_FILE_SIZE) {
+                            processed++;
+                            filesSkipped++;
+                            errors.push({
+                                message: `File exceeds max size (${stats.size} > ${MAX_FILE_SIZE})`,
+                                filePath,
+                                severity: 'warning',
+                                code: 'size_exceeded',
+                            });
+                            onProgress?.({ phase: 'parsing', current: processed, total });
+                            continue;
+                        }
+                        // Parse on the pool (main thread stays unblocked). Errors/timeouts are
+                        // handled inside feed() → recordParseFailure, feeding the retry pass.
+                        await feed(filePath, content, stats);
                     }
-                    if (error || content === null || stats === null) {
-                        processed++;
-                        filesErrored++;
-                        errors.push({
-                            message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-                            filePath,
-                            severity: 'error',
-                            code: 'read_error',
-                        });
-                        onProgress?.({ phase: 'parsing', current: processed, total });
-                        continue;
+                    if (aborted)
+                        break;
+                }
+                // Drain parses still in flight (skip on abort — we tear down below instead),
+                // then commit any results the cursor hasn't reached yet.
+                if (!aborted) {
+                    await Promise.all(inFlight);
+                    await flushOrdered();
+                    if (flushError) {
+                        if (storeWriter) {
+                            await storeWriter.close();
+                            storeWriter = null;
+                        }
+                        throw flushError;
                     }
-                    // Honour MAX_FILE_SIZE. Without this check, vendored generated
-                    // headers, minified bundles, and other multi-MB files get indexed,
-                    // wasting WASM heap and the worker recycle budget on inputs with no
-                    // useful symbols. The single-file extractFile path already enforces
-                    // this; the bulk path used to silently skip the check.
-                    if (stats.size > MAX_FILE_SIZE) {
-                        processed++;
-                        filesSkipped++;
-                        errors.push({
-                            message: `File exceeds max size (${stats.size} > ${MAX_FILE_SIZE})`,
-                            filePath,
-                            severity: 'warning',
-                            code: 'size_exceeded',
-                        });
-                        onProgress?.({ phase: 'parsing', current: processed, total });
-                        continue;
+                    if (storeWriter) {
+                        try {
+                            await storeWriter.drain();
+                        }
+                        finally {
+                            await storeWriter.close();
+                            storeWriter = null;
+                        }
                     }
-                    // Parse on the pool (main thread stays unblocked). Errors/timeouts are
-                    // handled inside feed() → recordParseFailure, feeding the retry pass.
-                    await feed(filePath, content, stats);
                 }
-                if (aborted)
-                    break;
-            }
-            // Drain parses still in flight (skip on abort — we tear down below instead),
-            // then commit any results the cursor hasn't reached yet.
-            if (!aborted) {
-                await Promise.all(inFlight);
-                await flushOrdered();
-                if (flushError) {
-                    if (storeWriter)
+                if (signal?.aborted || aborted) {
+                    if (storeWriter) {
                         await storeWriter.close();
-                    throw flushError;
+                        storeWriter = null;
+                    }
+                    if (pool)
+                        await pool.destroy();
+                    return {
+                        success: false,
+                        filesIndexed,
+                        filesSkipped,
+                        filesErrored,
+                        filesDiscovered: total,
+                        nodesCreated: totalNodes,
+                        edgesCreated: totalEdges,
+                        errors: [{ message: 'Aborted', severity: 'error' }, ...errors],
+                        durationMs: Date.now() - startTime,
+                    };
                 }
+            }
+            finally {
+                // Reclaim before retry / endBulk* — those paths need the main connection.
                 if (storeWriter) {
                     try {
-                        await storeWriter.drain();
-                    }
-                    finally {
                         await storeWriter.close();
-                        storeWriter = null;
                     }
+                    catch { /* best-effort */ }
+                    storeWriter = null;
                 }
-            }
-            if (signal?.aborted || aborted) {
-                if (storeWriter)
-                    await storeWriter.close();
-                if (pool)
-                    await pool.destroy();
-                return {
-                    success: false,
-                    filesIndexed,
-                    filesSkipped,
-                    filesErrored,
-                    filesDiscovered: total,
-                    nodesCreated: totalNodes,
-                    edgesCreated: totalEdges,
-                    errors: [{ message: 'Aborted', severity: 'error' }, ...errors],
-                    durationMs: Date.now() - startTime,
-                };
+                reclaimStoreHandoff();
             }
             // Report 100% so the progress bar doesn't hang at 99%
             onProgress?.({