homegraph 1.5.8 → 1.5.10

package/dist/extraction/languages/arkts.js

@@ -67,8 +67,10 @@ exports.cleanArkTypeString = cleanArkTypeString;
 exports.normalizeArktsReturnType = normalizeArktsReturnType;
 exports.buildArkMethodSignatureFields = buildArkMethodSignatureFields;
 exports.shouldUseIsolatedArkTSBuild = shouldUseIsolatedArkTSBuild;
+exports.preferHarmonySerialIndexing = preferHarmonySerialIndexing;
 exports.normalizeHarmonyModuleSrcPath = normalizeHarmonyModuleSrcPath;
 exports.listHarmonyProjectModules = listHarmonyProjectModules;
+exports.syntheticRootConflictsWithHarmonyModules = syntheticRootConflictsWithHarmonyModules;
 exports.findSyntheticArkModuleRoot = findSyntheticArkModuleRoot;
 exports.listOrphanArkAnalyzerSources = listOrphanArkAnalyzerSources;
 exports.listSyntheticArkModuleRoots = listSyntheticArkModuleRoots;
@@ -319,6 +321,23 @@ function shouldUseModularArkTSBuild(rootDir) {
         return true;
     return fs.existsSync(path.join(rootDir, 'build-profile.json5'));
 }
+/**
+ * Default to serial parse + no resolve worker pool on Harmony modular repos.
+ * analyseByModule dominates wall clock; worker pools mainly spike peak RSS after
+ * Scene release (Spec 0037). Explicit CODEGRAPH_PARSE_WORKERS still wins when set.
+ *
+ * - unset: true iff root `build-profile.json5` exists
+ * - `HOMEGRAPH_HARMONY_SERIAL=0`/`false`: never
+ * - `HOMEGRAPH_HARMONY_SERIAL=1`/`true`: always
+ */
+function preferHarmonySerialIndexing(rootDir) {
+    const mode = process.env.HOMEGRAPH_HARMONY_SERIAL?.trim();
+    if (mode === '0' || mode === 'false')
+        return false;
+    if (mode === '1' || mode === 'true')
+        return true;
+    return fs.existsSync(path.join(rootDir, 'build-profile.json5'));
+}
 /** Normalize build-profile `srcPath` / relative file paths for prefix matching. */
 function normalizeHarmonyModuleSrcPath(srcPath) {
     return srcPath.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '');
@@ -371,37 +390,72 @@ function resolveArkModuleAbsPath(rootDir, relSrcPath) {
     }
 }
 /**
- * Nearest package-like directory for an orphan Ark source, or the first path
- * segment. Never returns the project root (registering `.` would re-scan every
- * Harmony module). Lone files directly under the root return null.
+ * True when registering `srcPath` as a synthetic PROJECT would re-load real
+ * Harmony modules: exact path collision, or a parent of existing `srcPath`s
+ * (e.g. synthetic `feature/` swallowing `feature/appcenter`).
+ */
+function syntheticRootConflictsWithHarmonyModules(srcPath, modules) {
+    const src = normalizeHarmonyModuleSrcPath(srcPath);
+    if (!src || src === '.' || src === '')
+        return true;
+    for (const m of modules) {
+        const mod = m.srcPath;
+        if (mod === src || mod.startsWith(`${src}/`))
+            return true;
+    }
+    return false;
+}
+/**
+ * Nearest **Node** `package.json` directory for an orphan Ark/TS source.
+ * Never returns the project root (registering `.` would re-scan every Harmony
+ * module). Lone files directly under the root return null.
+ *
+ * Only `package.json` counts — not `oh-package.json5`. Forgotten Harmony HARs
+ * left out of root `build-profile.json5` (scene_board `feature/visionglass`
+ * etc.) often declare heavy `file:`/`../` deps on modules already indexed as
+ * real PROJECT modules; registering them as synthetic PROJECT→BODIES reloads
+ * those deps into ModuleCache and spikes wall time + RSS for almost no unique
+ * coverage. Those orphans fall through to tree-sitter instead.
+ *
+ * When `harmonyModules` is provided, skips roots that would swallow those
+ * modules (e.g. a plugin under `feature/intelligent` must not become
+ * `synthetic:feature/` and re-BODIES the whole `feature/` tree).
  */
-function findSyntheticArkModuleRoot(rootDir, relFile) {
+function findSyntheticArkModuleRoot(rootDir, relFile, harmonyModules = []) {
     const file = normIndexPath(relFile);
     if (!file || file.startsWith('@'))
         return null;
-    let dir = path.posix.dirname(file);
+    const dir = path.posix.dirname(file);
     if (dir === '.' || dir === '')
         return null;
     const rootAbs = path.resolve(rootDir);
+    const candidates = [];
     let curAbs = path.resolve(rootDir, dir);
     for (;;) {
         const relFromRoot = path.relative(rootAbs, curAbs);
         if (!relFromRoot || relFromRoot.startsWith('..') || path.isAbsolute(relFromRoot))
             break;
-        const rel = relFromRoot.replace(/\\/g, '/');
-        if (fs.existsSync(path.join(curAbs, 'package.json')) ||
-            fs.existsSync(path.join(curAbs, 'oh-package.json5'))) {
-            return normalizeHarmonyModuleSrcPath(rel);
-        }
+        const rel = normalizeHarmonyModuleSrcPath(relFromRoot.replace(/\\/g, '/'));
+        if (rel && rel !== '.')
+            candidates.push(rel);
         const parent = path.dirname(curAbs);
         if (parent === curAbs)
             break;
         curAbs = parent;
     }
-    const first = file.split('/')[0];
-    if (!first || first === file)
+    if (candidates.length === 0)
         return null;
-    return normalizeHarmonyModuleSrcPath(first);
+    const safe = (rel) => !syntheticRootConflictsWithHarmonyModules(rel, harmonyModules);
+    // Nearest package.json that does not swallow Harmony modules (Node plugins).
+    for (const rel of candidates) {
+        if (!safe(rel))
+            continue;
+        const abs = path.resolve(rootDir, rel);
+        if (fs.existsSync(path.join(abs, 'package.json'))) {
+            return rel;
+        }
+    }
+    return null;
 }
 /**
  * ArkAnalyzer sources under `scannedFiles` that are not inside any
@@ -421,19 +475,21 @@ function listOrphanArkAnalyzerSources(scannedFiles, harmonyModules) {
     return orphans;
 }
 /**
- * Cluster orphan `.ets`/`.ts`/`.d.ts` into synthetic PROJECT module roots
- * (e.g. `HMRouterPlugin` for a Node hvigor plugin living beside HAP modules).
+ * Cluster orphan `.ets`/`.ts`/`.d.ts` into synthetic PROJECT module roots for
+ * Node-style packages only (`package.json`, e.g. HMRouterPlugin). Harmony
+ * `oh-package.json5` trees omitted from build-profile are not registered —
+ * analyseByModule would re-SIGNATURES their monorepo deps at high RSS cost.
  */
 function listSyntheticArkModuleRoots(rootDir, scannedFiles, harmonyModules) {
     const modules = harmonyModules ?? listHarmonyProjectModules(rootDir);
     const orphans = listOrphanArkAnalyzerSources(scannedFiles, modules);
     const bySrc = new Map();
     for (const f of orphans) {
-        const srcPath = findSyntheticArkModuleRoot(rootDir, f);
+        const srcPath = findSyntheticArkModuleRoot(rootDir, f, modules);
         if (!srcPath)
             continue;
-        // Never shadow a real Harmony module path.
-        if (modules.some((m) => m.srcPath === srcPath))
+        // Belt-and-suspenders with findSyntheticArkModuleRoot's conflict check.
+        if (syntheticRootConflictsWithHarmonyModules(srcPath, modules))
             continue;
         if (bySrc.has(srcPath))
             continue;
@@ -914,14 +970,27 @@ function tryForceGc() {
         }
     }
 }
+/** Compact stderr phase/heartbeat lines for ArkTS index stalls (scene_board-scale). */
+function arktsPhaseLog(msg) {
+    const mu = process.memoryUsage();
+    const heap = (mu.heapUsed / 1024 / 1024).toFixed(0);
+    const rss = (mu.rss / 1024 / 1024).toFixed(0);
+    process.stderr.write(`\x1b[36m    ArkTS[${new Date().toISOString()}] ${msg} (heap=${heap}MB rss=${rss}MB)\x1b[0m\n`);
+}
 /**
  * Unload every module's IR then dispose Scene globals. Plain `scene.dispose()`
  * only clears SDK helpers / moduleCache — project ArkFiles stay reachable and
  * pin multi-GB RSS into Parsing/Resolving.
  */
 function releaseArkAnalyzerScene(scene) {
+    const t0 = Date.now();
+    let n = 0;
+    let total = -1;
     try {
-        for (const mod of scene.getModules()) {
+        const mods = [...scene.getModules()];
+        total = mods.length;
+        arktsPhaseLog(`releaseScene: disposing ${total} module(s)…`);
+        for (const mod of mods) {
             try {
                 scene.disposeModule(mod);
                 mod.setFileDepGraph(undefined);
@@ -931,18 +1000,24 @@ function releaseArkAnalyzerScene(scene) {
             catch {
                 // per-module best-effort
             }
+            n++;
+            if (n === 1 || n === total || n % 25 === 0) {
+                arktsPhaseLog(`releaseScene: disposed ${n}/${total}`);
+            }
         }
     }
     catch {
         // ignore
     }
     try {
+        arktsPhaseLog('releaseScene: scene.dispose()…');
         scene.dispose();
     }
     catch {
         // ignore
     }
     tryForceGc();
+    arktsPhaseLog(`releaseScene: done in ${Date.now() - t0}ms (disposed ${n}/${total})`);
 }
 /**
  * ArkAnalyzer 1.0.92 keeps INDEX hollow on {@link ModuleBuilder} as a private
@@ -1109,18 +1184,20 @@ function runArkTSBatch(rootDir, queries, triggerFile) {
         return cached;
     }
     // indexAll releases the in-memory payload after SQLite persist. A later
-    // ArkTSExtractor hit must NOT rebuild the entire Scene (looks like a restart).
-    if (batchBuildCommitted &&
-        persistedBatch &&
-        persistedBatch.rootDir === rootDir &&
-        batchPersistedPaths.has(normalizedTrigger)) {
+    // ArkTSExtractor hit must NOT rebuild the entire Scene (looks like a restart
+    // after "127/127 … releaseScene done"). That includes orphans that were never
+    // in a PROJECT module — they are meant to fall through to tree-sitter, not
+    // trigger a second analyseByModule without streamPersist.
+    if (batchBuildCommitted && persistedBatch && persistedBatch.rootDir === rootDir) {
         return {
             fileResults: new Map(),
             crossFileEdges: [],
             nodeIds: new Set(),
             errors: [
                 {
-                    message: 'ArkTS batch already persisted this run; in-memory payload released',
+                    message: batchPersistedPaths.has(normalizedTrigger)
+                        ? 'ArkTS batch already persisted this run; in-memory payload released'
+                        : 'ArkTS batch already finished this run; file was outside PROJECT modules (tree-sitter fallback)',
                     severity: 'warning',
                 },
             ],
@@ -4035,7 +4112,7 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
     };
     try {
         scene.config(sceneConfig);
-        // Register build-profile modules + orphan trees (no oh-package) before the
+        // Register build-profile modules + Node package.json orphan plugins before the
         // dep graph is frozen — otherwise analyseByModule never sees HMRouterPlugin-style .ts.
         const synthetics = prepareArkModulesWithSynthetics(scene, rootDir, scannedList);
         if (synthetics.length > 0) {
@@ -4079,67 +4156,115 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
             config.setIncludeType(arkanalyzer_1.ModuleType.PROJECT, true);
             process.stderr.write(`\n\x1b[33m    ArkTS: analyseByModule (PROJECT→BODIES, deps→SIGNATURES, memoryLimitMB=${memoryLimitMB}, maxOldSpace=${(0, wasm_runtime_flags_1.resolveMaxOldSpaceSizeMb)()}${streamQueries ? ', streamPersist' : ''})...\x1b[0m\n`);
         }
-        scene.analyseByModule((module, scn) => {
-            const moduleFileRels = [...module.getFilesMap().values()]
-                .map((f) => adapter.normalizeRelPath(f.getFilePath()))
-                .filter((p) => p && isArkAnalyzerSourcePath(p))
-                .map(normIndexPath);
-            adapter.indexModule(module, scn);
-            // HomeGraph already captured this module's symbols/edges. Hollow every
-            // currently-loaded module still above INDEX (target + oh_modules /
-            // SIGNATURES deps left in ModuleCache). Topo order means PROJECT deps of
-            // the current target are often already INDEX from their own callback, so
-            // BFS-from-self alone left depHollowed=0; sweeping the cache catches the
-            // fat non-target SIGNATURES that memoryLimitMB rarely evicts under a large
-            // soft budget. INDEX keeps export-reachable shells; loadModule upgrades
-            // when a later target needs SIGNATURES/BODIES.
-            let depHollowed = 0;
-            try {
-                const builder = new arkanalyzer_1.ModuleBuilder(scn);
-                const selfId = scn.getModuleId(module);
-                hollowModuleToIndex(builder, selfId);
-                const cache = scn.getModuleCache();
-                if (cache) {
-                    for (const modId of cache.getLoadedModules()) {
-                        if (modId === selfId)
-                            continue;
-                        const depMod = builder.getModule(modId);
-                        if (!depMod || depMod.getLoadState() <= arkanalyzer_1.ModuleLoadState.INDEX)
-                            continue;
-                        hollowModuleToIndex(builder, modId);
-                        depHollowed++;
-                    }
-                }
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                errors.push({
-                    message: `ArkTS post-index INDEX hollow failed for ${module.getModuleName() || module.getModulePath()}: ${message}`,
-                    severity: 'warning',
-                });
+        let projectModuleCount = 0;
+        try {
+            for (const mod of scene.getModules()) {
+                if (mod.getModuleType() === arkanalyzer_1.ModuleType.PROJECT)
+                    projectModuleCount++;
             }
-            if (streamQueries) {
-                // Persist this module's file bodies now; keep @dummyFile until finalize.
-                const slicePaths = moduleFileRels.filter((p) => p !== ARKANALYZER_DUMMY_FILE);
-                const slice = adapter.takeFileResults(slicePaths);
+        }
+        catch {
+            projectModuleCount = -1;
+        }
+        // Heartbeat: analyseByModule is native between callbacks — without this the
+        // CLI looks frozen after the last `indexed module` line (scene_board ~127).
+        let lastCallbackAt = Date.now();
+        let lastCallbackName = '(none)';
+        let inCallback = false;
+        const analyseStartedAt = Date.now();
+        const heartbeat = setInterval(() => {
+            const idleSec = ((Date.now() - lastCallbackAt) / 1000).toFixed(1);
+            arktsPhaseLog(`heartbeat: analyseByModule still running — modulesDone=${modulesIndexed}/${projectModuleCount} ` +
+                `last=${lastCallbackName} inCallback=${inCallback} idleSinceCallback=${idleSec}s ` +
+                `elapsed=${((Date.now() - analyseStartedAt) / 1000).toFixed(0)}s`);
+        }, 10_000);
+        // Don't keep the process alive solely for the heartbeat if AA finishes.
+        heartbeat.unref?.();
+        arktsPhaseLog(`analyseByModule: ENTER expectedProjectModules=${projectModuleCount} scannedFiles=${scannedList.length}`);
+        try {
+            scene.analyseByModule((module, scn) => {
+                inCallback = true;
+                const callbackStarted = Date.now();
+                const name = module.getModuleName() || path.basename(module.getModulePath());
+                const gapSec = ((callbackStarted - lastCallbackAt) / 1000).toFixed(1);
+                if (modulesIndexed > 0 && callbackStarted - lastCallbackAt >= 15_000) {
+                    arktsPhaseLog(`analyseByModule: gap before "${name}" — ${gapSec}s native since module ${modulesIndexed}`);
+                }
+                const moduleFileRels = [...module.getFilesMap().values()]
+                    .map((f) => adapter.normalizeRelPath(f.getFilePath()))
+                    .filter((p) => p && isArkAnalyzerSourcePath(p))
+                    .map(normIndexPath);
+                const tIndex = Date.now();
+                adapter.indexModule(module, scn);
+                const indexMs = Date.now() - tIndex;
+                // HomeGraph already captured this module's symbols/edges. Hollow every
+                // currently-loaded module still above INDEX (target + oh_modules /
+                // SIGNATURES deps left in ModuleCache). Topo order means PROJECT deps of
+                // the current target are often already INDEX from their own callback, so
+                // BFS-from-self alone left depHollowed=0; sweeping the cache catches the
+                // fat non-target SIGNATURES that memoryLimitMB rarely evicts under a large
+                // soft budget. INDEX keeps export-reachable shells; loadModule upgrades
+                // when a later target needs SIGNATURES/BODIES.
+                let depHollowed = 0;
+                const tHollow = Date.now();
                 try {
-                    persistAndDropModuleSlice(rootDir, streamQueries, slice, streamedPersistedPaths, persistOrdinal);
+                    const builder = new arkanalyzer_1.ModuleBuilder(scn);
+                    const selfId = scn.getModuleId(module);
+                    hollowModuleToIndex(builder, selfId);
+                    const cache = scn.getModuleCache();
+                    if (cache) {
+                        for (const modId of cache.getLoadedModules()) {
+                            if (modId === selfId)
+                                continue;
+                            const depMod = builder.getModule(modId);
+                            if (!depMod || depMod.getLoadState() <= arkanalyzer_1.ModuleLoadState.INDEX)
+                                continue;
+                            hollowModuleToIndex(builder, modId);
+                            depHollowed++;
+                        }
+                    }
                 }
                 catch (e) {
                     const message = e instanceof Error ? e.message : String(e);
                     errors.push({
-                        message: `ArkTS stream persist failed for ${module.getModuleName() || module.getModulePath()}: ${message}`,
-                        severity: 'error',
+                        message: `ArkTS post-index INDEX hollow failed for ${module.getModuleName() || module.getModulePath()}: ${message}`,
+                        severity: 'warning',
                     });
-                    throw e;
                 }
-            }
-            modulesIndexed++;
-            const name = module.getModuleName() || path.basename(module.getModulePath());
-            const st = arkanalyzer_1.ModuleLoadState[module.getLoadState()] ?? String(module.getLoadState());
-            const depNote = depHollowed > 0 ? `, hollowed ${depHollowed} deps` : '';
-            process.stderr.write(`\x1b[33m    ArkTS: indexed module ${modulesIndexed}: ${name} → ${st}${depNote}${streamQueries ? ` (streamed ${moduleFileRels.length} files)` : ''}\x1b[0m\n`);
-        }, config);
+                const hollowMs = Date.now() - tHollow;
+                let persistMs = 0;
+                if (streamQueries) {
+                    // Persist this module's file bodies now; keep @dummyFile until finalize.
+                    const slicePaths = moduleFileRels.filter((p) => p !== ARKANALYZER_DUMMY_FILE);
+                    const slice = adapter.takeFileResults(slicePaths);
+                    const tPersist = Date.now();
+                    try {
+                        persistAndDropModuleSlice(rootDir, streamQueries, slice, streamedPersistedPaths, persistOrdinal);
+                    }
+                    catch (e) {
+                        const message = e instanceof Error ? e.message : String(e);
+                        errors.push({
+                            message: `ArkTS stream persist failed for ${module.getModuleName() || module.getModulePath()}: ${message}`,
+                            severity: 'error',
+                        });
+                        throw e;
+                    }
+                    persistMs = Date.now() - tPersist;
+                }
+                modulesIndexed++;
+                lastCallbackAt = Date.now();
+                lastCallbackName = name;
+                inCallback = false;
+                const st = arkanalyzer_1.ModuleLoadState[module.getLoadState()] ?? String(module.getLoadState());
+                const depNote = depHollowed > 0 ? `, hollowed ${depHollowed} deps` : '';
+                const timingNote = ` [gap=${gapSec}s idx=${indexMs}ms hollow=${hollowMs}ms persist=${persistMs}ms total=${Date.now() - callbackStarted}ms]`;
+                process.stderr.write(`\x1b[33m    ArkTS: indexed module ${modulesIndexed}/${projectModuleCount}: ${name} → ${st}${depNote}${streamQueries ? ` (streamed ${moduleFileRels.length} files)` : ''}${timingNote}\x1b[0m\n`);
+            }, config);
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+        arktsPhaseLog(`analyseByModule: RETURNED modulesIndexed=${modulesIndexed}/${projectModuleCount} in ${Date.now() - analyseStartedAt}ms`);
         if (process.env.HOMEGRAPH_ARKTS_DIAG === '1') {
             const sceneDiag = scene;
             const ev = typeof sceneDiag.getModuleEvictionStats === 'function'
@@ -4158,7 +4283,10 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
             return emptyArkTSBatchIndex(errors);
         }
         try {
+            const tFin = Date.now();
+            arktsPhaseLog('finalizeCallGraph: ENTER');
             adapter.finalizeCallGraph(scene);
+            arktsPhaseLog(`finalizeCallGraph: DONE in ${Date.now() - tFin}ms`);
         }
         catch (e) {
             const message = e instanceof Error ? e.message : String(e);
@@ -4166,10 +4294,14 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
                 message: `ArkTS modular leftover RTA skipped: ${message}`,
                 severity: 'warning',
             });
+            arktsPhaseLog(`finalizeCallGraph: SKIPPED (${message})`);
         }
         if (streamQueries) {
+            const tLeft = Date.now();
+            arktsPhaseLog('leftoverPersist: ENTER');
             const leftover = adapter.takeFileResults(adapter.fileResultPaths());
             persistAndDropModuleSlice(rootDir, streamQueries, leftover, streamedPersistedPaths, persistOrdinal);
+            arktsPhaseLog(`leftoverPersist: DONE in ${Date.now() - tLeft}ms leftoverFiles=${leftover.size} streamedTotal=${streamedPersistedPaths.size}`);
         }
         const index = adapter.toBatchIndex(errors);
         if (streamQueries) {
@@ -4182,6 +4314,7 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
             });
             return emptyArkTSBatchIndex(errors);
         }
+        arktsPhaseLog('buildArkTSIndexByModuleInner: returning index (finally will releaseScene)');
         return index;
     }
     catch (e) {
@@ -4190,6 +4323,7 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
             message: `ArkTS analyseByModule failed: ${message}; falling back to full Scene build`,
             severity: 'warning',
         });
+        arktsPhaseLog(`analyseByModule: FAILED — ${message}`);
         return emptyArkTSBatchIndex(errors);
     }
     finally {
@@ -4564,13 +4698,85 @@ function markOhosApiFilePath(relativePath) {
 function isOhosApiFilePath(filePath) {
     return filePath.startsWith(exports.OHOS_API_FILE_PREFIX);
 }
-/** Strip json5 comments/trailing commas enough for compileSdkVersion extraction. */
+/**
+ * DevEco / Harmony JSON5 subset → JSON.parse.
+ * Supports: line/block comments, trailing commas, bare keys, single-quoted strings
+ * (e.g. deviceTypes: ['phone', '2in1']). Not a full JSON5 implementation.
+ */
 function parseJson5Minimal(text) {
-    const stripped = text
+    let s = text
         .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .replace(/,(\s*[}\]])/g, '$1');
-    return JSON.parse(stripped);
+        .replace(/\/\*[\s\S]*?\*\//g, '');
+    // Quote bare keys before touching string quotes.
+    s = s.replace(/([{,]\s*)([A-Za-z_][\w]*)\s*:/g, '$1"$2":');
+    s = convertJson5SingleQuotedStrings(s);
+    s = s.replace(/,(\s*[}\]])/g, '$1');
+    return JSON.parse(s);
+}
+/** Convert `'…'` string literals to JSON `"…"` outside existing double-quoted strings. */
+function convertJson5SingleQuotedStrings(input) {
+    let out = '';
+    let i = 0;
+    while (i < input.length) {
+        const c = input[i];
+        if (c === '"') {
+            out += c;
+            i++;
+            while (i < input.length) {
+                const ch = input[i];
+                out += ch;
+                i++;
+                if (ch === '\\' && i < input.length) {
+                    out += input[i];
+                    i++;
+                    continue;
+                }
+                if (ch === '"')
+                    break;
+            }
+            continue;
+        }
+        if (c === "'") {
+            out += '"';
+            i++;
+            while (i < input.length) {
+                const ch = input[i];
+                if (ch === '\\' && i + 1 < input.length) {
+                    const next = input[i + 1];
+                    i += 2;
+                    if (next === "'") {
+                        out += "'";
+                    }
+                    else if (next === '"') {
+                        out += '\\"';
+                    }
+                    else if (next === '\\') {
+                        out += '\\\\';
+                    }
+                    else {
+                        out += '\\' + next;
+                    }
+                    continue;
+                }
+                if (ch === "'") {
+                    out += '"';
+                    i++;
+                    break;
+                }
+                if (ch === '"') {
+                    out += '\\"';
+                    i++;
+                    continue;
+                }
+                out += ch;
+                i++;
+            }
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return out;
 }
 /** Normalize compileSdkVersion values like "6.0.1(21)" → "6.0.1". */
 function normalizeOhosApiVersion(raw) {

package/dist/extraction/tree-sitter.js

@@ -6512,9 +6512,18 @@ function extractFromSource(filePath, source, language, frameworkNames) {
         result = extractor.extract();
     }
     else if (detectedLanguage === 'arkts') {
-        // HomeGraph uses the arkanalyzer-backed ArkTS extractor (not tree-sitter).
-        const extractor = new arkts_1.ArkTSExtractor(filePath, source);
-        result = extractor.extract();
+        // Prefer ArkAnalyzer via ArkTSExtractor. After a committed modular/full batch,
+        // files that never entered a PROJECT module must NOT call ArkTSExtractor —
+        // that path would rebuild the entire Scene (second analyseByModule). Use the
+        // TypeScript grammar as a shallow symbol fallback for those orphans.
+        if ((0, arkts_1.isArkTSBatchCommitted)() && !(0, arkts_1.isArkTSBatchPersisted)(filePath)) {
+            const extractor = new TreeSitterExtractor(filePath, source, 'typescript');
+            result = extractor.extract();
+        }
+        else {
+            const extractor = new arkts_1.ArkTSExtractor(filePath, source);
+            result = extractor.extract();
+        }
     }
     else if ((0, grammars_1.isFileLevelOnlyLanguage)(detectedLanguage)) {
         // No symbol extraction at this stage — files are tracked at the file-record

package/dist/index.js

@@ -451,6 +451,11 @@ class HomeGraph {
             catch {
                 return { success: false, filesIndexed: 0, filesSkipped: 0, filesErrored: 0, nodesCreated: 0, edgesCreated: 0, errors: [{ message: 'Could not acquire file lock - another process may be indexing', severity: 'error' }], durationMs: 0 };
             }
+            // Wall clock for the whole indexAll critical section (extract + FTS rebuild
+            // + resolve/link + maintenance + optional ohos API bind). Orchestrator
+            // durationMs only covers extract/store — printing that alone under-reports
+            // large Harmony repos where resolving dominates the remaining minutes.
+            const wallStartedAt = Date.now();
             const freshDb = this.queries.getNodeAndEdgeCount().nodes === 0;
             const fastInit = process.env.HOMEGRAPH_NO_FAST_INIT !== '1' && freshDb;
             if (fastInit) {
@@ -594,6 +599,7 @@ class HomeGraph {
                     }
                 }
                 catch { /* metadata is advisory — never fail an index over it */ }
+                result.durationMs = Date.now() - wallStartedAt;
                 return result;
             }
             finally {
@@ -1002,18 +1008,23 @@ class HomeGraph {
      * Processes chunks of unresolved refs, persisting results after each batch.
      */
     async resolveReferencesBatched(onProgress, onSynthesisProgress, backpressure) {
-        return this.resolver.resolveAndPersistBatched(onProgress, undefined, onSynthesisProgress, {
-            dbPath: this.db.getPath(),
-            bulkEdgeLoad: {
-                begin: () => this.db.beginBulkEdgeLoad(),
-                end: () => this.db.endBulkEdgeLoad(),
-            },
-            refIndexLoad: {
-                begin: () => this.db.beginBulkRefLoad(),
-                end: () => this.db.endBulkRefLoad(),
-            },
-            backpressure,
-        });
+        // Harmony modular repos: skip ResolverPool (Spec 0037). Synthesis then runs
+        // on the main thread with concurrency 1 — same peak profile as Plan D.
+        const parallel = (0, arkts_1.preferHarmonySerialIndexing)(this.projectRoot)
+            ? undefined
+            : {
+                dbPath: this.db.getPath(),
+                bulkEdgeLoad: {
+                    begin: () => this.db.beginBulkEdgeLoad(),
+                    end: () => this.db.endBulkEdgeLoad(),
+                },
+                refIndexLoad: {
+                    begin: () => this.db.beginBulkRefLoad(),
+                    end: () => this.db.endBulkRefLoad(),
+                },
+                backpressure,
+            };
+        return this.resolver.resolveAndPersistBatched(onProgress, undefined, onSynthesisProgress, parallel);
     }
     /**
      * Get detected frameworks in the project

package/dist/mcp/index-availability.d.ts

@@ -1,23 +1,31 @@
 /**
- * Product-facing index availability for MCP tool results (Spec 0032).
+ * Product-facing index availability for MCP tool results (Spec 0032 + 0035).
  *
- * Internal `build_phase` stays as-is; this layer maps it (+ write-lock / busy)
- * to the four states hosts and agents should see in tool text.
+ * Internal `build_phase` stays as-is; this layer maps it (+ write-lock / busy /
+ * pending dirty files) to the five states hosts and agents should see.
  */
 import type HomeGraph from '../index';
 /** Agent-visible index readiness (tool return copy — not tools/list gating). */
-export type ProductIndexState = 'empty' | 'fast' | 'full' | 'syncing';
-export declare function productIndexGuidance(state: Exclude<ProductIndexState, 'full'>): string;
+export type ProductIndexState = 'empty' | 'fast' | 'full' | 'dirty' | 'syncing';
+/** One-line glossary for MCP initialize / tool surface (Spec 0035). */
+export declare const PRODUCT_STATUS_GLOSSARY = "status: empty=not ready \u00B7 fast=map only (homegraph_project) \u00B7 full=fresh \u00B7 dirty=usable but listed paths outdated \u00B7 syncing=write lock, retry";
+/** Whole-response guidance when the tool cannot usefully answer yet. */
+export declare function productIndexGuidance(state: Extract<ProductIndexState, 'empty' | 'fast' | 'syncing'>): string;
+/**
+ * Single status line for tool footers (and for guidance-only replies).
+ * `pendingPaths` only used when `state === 'dirty'`.
+ */
+export declare function formatProductStatusLine(state: ProductIndexState, opts?: {
+    pendingPaths?: string[];
+}): string;
 /**
  * Resolve the product state from a live HomeGraph handle.
  *
- * - empty: fast map not ready (`none` / `building_fast`)
- * - fast: map ready, full index not done (`fast` / `indexing`)
- * - full: symbol index ready
- * - syncing: full (or empty-while-contended-init) and a writer holds the lock /
- *   this process is indexing — reads may fail or see a moving target
+ * Priority: syncing > empty > fast > dirty > full
  */
 export declare function resolveProductIndexState(cg: HomeGraph): ProductIndexState;
 /** True when an error message indicates SQLite writer contention. */
 export declare function isSqliteBusyMessage(message: string): boolean;
+/** True when text is already a pure (or leading) HomeGraph status line. */
+export declare function textAlreadyHasProductStatus(text: string): boolean;
 //# sourceMappingURL=index-availability.d.ts.map