homegraph 1.5.3 → 1.5.5

package/dist/mcp/tools.js

@@ -11,10 +11,15 @@ exports.normalizeQuerySpelling = normalizeQuerySpelling;
 exports.getExploreBudget = getExploreBudget;
 exports.getExploreOutputBudget = getExploreOutputBudget;
 exports.tightenExploreBudgetForQuery = tightenExploreBudgetForQuery;
+exports.exploreLocatorDigestEnabled = exploreLocatorDigestEnabled;
 exports.formatStaleBanner = formatStaleBanner;
 exports.formatStaleFooter = formatStaleFooter;
 exports.formatDegradedBanner = formatDegradedBanner;
 exports.getStaticTools = getStaticTools;
+exports.extractBareUsageSymbols = extractBareUsageSymbols;
+exports.queryAsBareSymbolInventory = queryAsBareSymbolInventory;
+exports.hasPositiveAnswerNowDirective = hasPositiveAnswerNowDirective;
+exports.reconcilePartialAnswerNow = reconcilePartialAnswerNow;
 const query_pool_1 = require("./query-pool");
 const memory_budget_1 = require("./memory-budget");
 const directory_1 = require("../directory");
@@ -34,6 +39,7 @@ function __setLoadHomeGraphForTests(cls) {
     loadHomeGraphForTests = cls;
 }
 const worktree_1 = require("../sync/worktree");
+const update_check_1 = require("../upgrade/update-check");
 const graph_sources_1 = require("../graph-sources");
 const query_utils_1 = require("../search/query-utils");
 const fs_1 = require("fs");
@@ -43,6 +49,7 @@ const generated_detection_1 = require("../extraction/generated-detection");
 const arkts_1 = require("../extraction/languages/arkts");
 const explore_session_state_1 = require("./explore-session-state");
 const explore_dedup_1 = require("./explore-dedup");
+const explore_repeat_guard_1 = require("./explore-repeat-guard");
 const dynamic_boundaries_1 = require("./dynamic-boundaries");
 const query_cache_1 = require("./query-cache");
 const diff_impact_1 = require("./diff-impact");
@@ -278,25 +285,19 @@ function getExploreBudget(fileCount) {
 function getExploreOutputBudget(fileCount) {
     // Tiered budget, scaled to project size. The budget is a CEILING (relevance
     // still gates WHAT is included), and it MUST stay under the agent's INLINE
-    // tool-result cap (~25K chars). Above that, the host externalizes the result
-    // to a file the agent then Reads back — re-introducing a read AND the
-    // cache-write cost — which is exactly what a 35K vscode explore did in the
-    // n=4 README A/B. So even large repos cap at ~24K: the answer is the handful
-    // of ~100-line flow windows the agent would have grep-located and read (it
-    // natively reads ~6–9 files, median 100-line ranges), NOT a sprawl of 12
-    // files. Concentration onto the flow emerges from this cap + the named-file-
-    // first sort dropping peripheral files. Invariant: a larger tier must never
-    // get a smaller `maxCharsPerFile` than a smaller tier.
+    // tool-result cap (~25K chars).
+    //
+    // Default = universal mid-lean locator (anchors + spine digests ~12K): enough
+    // evidence to stop a Read storm, not a multi-file body dump. Set
+    // HOMEGRAPH_EXPLORE_FULL_SOURCE=1 for the prior fatter shape.
+    // Invariant: a larger tier must never get a smaller `maxCharsPerFile` than a
+    // smaller tier.
+    const digest = exploreLocatorDigestEnabled();
     if (fileCount < 150) {
         return {
-            // ITER3: revert iter2's aggressive body shrink (forced Read fallback —
-            // the per-file 2.5K cap pushed the agent to Read instead of node).
-            // Back to the iter1 shape (13K/4/3.8K) but keep the test-file
-            // hard-exclude. The cost lever for this tier lives in steering the
-            // agent to stop after 1-2 calls, not in this budget.
-            maxOutputChars: 13000,
-            defaultMaxFiles: 4,
-            maxCharsPerFile: 3800,
+            maxOutputChars: digest ? 10000 : 13000,
+            defaultMaxFiles: digest ? 2 : 4,
+            maxCharsPerFile: digest ? 2500 : 3800,
             gapThreshold: 7,
             maxSymbolsInFileHeader: 5,
             maxEdgesPerRelationshipKind: 4,
@@ -309,10 +310,9 @@ function getExploreOutputBudget(fileCount) {
     }
     if (fileCount < 500) {
         return {
-            // ITER3: same revert/keep-filter pattern as <150.
-            maxOutputChars: 18000,
-            defaultMaxFiles: 5,
-            maxCharsPerFile: 3800,
+            maxOutputChars: digest ? 12000 : 18000,
+            defaultMaxFiles: digest ? 2 : 5,
+            maxCharsPerFile: digest ? 2800 : 3800,
             gapThreshold: 8,
             maxSymbolsInFileHeader: 6,
             maxEdgesPerRelationshipKind: 6,
@@ -325,53 +325,48 @@ function getExploreOutputBudget(fileCount) {
     }
     if (fileCount < 5000) {
         return {
-            // ~150-line per-file window (the native read unit) × ~6 files, capped at
-            // the ~24K inline ceiling so the response is never externalized. Per-file
-            // stays ≥ the <500 tier (3800) — monotonic.
-            maxOutputChars: 24000,
-            defaultMaxFiles: 8,
-            maxCharsPerFile: 6500,
-            gapThreshold: 12,
-            maxSymbolsInFileHeader: 10,
-            maxEdgesPerRelationshipKind: 10,
-            includeRelationships: true,
-            includeAdditionalFiles: true,
-            includeCompletenessSignal: true,
-            includeBudgetNote: true,
-            excludeLowValueFiles: false,
+            // Mid-lean: anchors + 1–2 spine digests. Per-file ≥ smaller tiers.
+            maxOutputChars: digest ? 12000 : 18000,
+            defaultMaxFiles: digest ? 2 : 6,
+            maxCharsPerFile: digest ? 3000 : 6500,
+            gapThreshold: digest ? 10 : 12,
+            maxSymbolsInFileHeader: digest ? 8 : 10,
+            maxEdgesPerRelationshipKind: digest ? 6 : 10,
+            includeRelationships: false,
+            includeAdditionalFiles: false,
+            includeCompletenessSignal: false,
+            includeBudgetNote: false,
+            excludeLowValueFiles: true,
         };
     }
-    // Large + very-large repos: SAME ~24K inline ceiling (a bigger response just
-    // externalizes — see vscode). More files indexed → more CALLS via
-    // getExploreBudget, not a bigger single response. Per-file 7000 (≥ smaller
-    // tiers) gives the central file a ~180-line orientation window.
+    // Large + very-large: same mid-lean ceiling; scale via getExploreBudget calls.
     if (fileCount < 15000) {
         return {
-            maxOutputChars: 24000,
-            defaultMaxFiles: 8,
-            maxCharsPerFile: 7000,
-            gapThreshold: 15,
-            maxSymbolsInFileHeader: 15,
-            maxEdgesPerRelationshipKind: 15,
-            includeRelationships: true,
-            includeAdditionalFiles: true,
-            includeCompletenessSignal: true,
-            includeBudgetNote: true,
-            excludeLowValueFiles: false,
+            maxOutputChars: digest ? 12000 : 18000,
+            defaultMaxFiles: digest ? 2 : 6,
+            maxCharsPerFile: digest ? 3000 : 7000,
+            gapThreshold: digest ? 10 : 15,
+            maxSymbolsInFileHeader: digest ? 8 : 12,
+            maxEdgesPerRelationshipKind: digest ? 6 : 12,
+            includeRelationships: false,
+            includeAdditionalFiles: false,
+            includeCompletenessSignal: false,
+            includeBudgetNote: false,
+            excludeLowValueFiles: true,
         };
     }
     return {
-        maxOutputChars: 24000,
-        defaultMaxFiles: 8,
-        maxCharsPerFile: 7000,
-        gapThreshold: 15,
-        maxSymbolsInFileHeader: 15,
-        maxEdgesPerRelationshipKind: 15,
-        includeRelationships: true,
-        includeAdditionalFiles: true,
-        includeCompletenessSignal: true,
-        includeBudgetNote: true,
-        excludeLowValueFiles: false,
+        maxOutputChars: digest ? 12000 : 18000,
+        defaultMaxFiles: digest ? 2 : 6,
+        maxCharsPerFile: digest ? 3000 : 7000,
+        gapThreshold: digest ? 10 : 15,
+        maxSymbolsInFileHeader: digest ? 8 : 12,
+        maxEdgesPerRelationshipKind: digest ? 6 : 12,
+        includeRelationships: false,
+        includeAdditionalFiles: false,
+        includeCompletenessSignal: false,
+        includeBudgetNote: false,
+        excludeLowValueFiles: true,
     };
 }
 /**
@@ -384,13 +379,15 @@ function getExploreOutputBudget(fileCount) {
  * implemented" questions even when the first answer was already enough.
  */
 function tightenExploreBudgetForQuery(budget, query, opts) {
+    const digest = exploreLocatorDigestEnabled();
     const hasFlow = opts?.hasFlowPath === true;
     if (hasFlow && ((0, query_utils_1.queryAsMechanismSurvey)(query) || (0, query_utils_1.queryAsCrossModuleFlowSurvey)(query))) {
         return {
             ...budget,
-            maxOutputChars: Math.min(budget.maxOutputChars, 12000),
-            defaultMaxFiles: Math.min(budget.defaultMaxFiles, 4),
-            maxCharsPerFile: Math.min(budget.maxCharsPerFile, 4500),
+            // Mid-lean: keep enough spine to avoid a Read storm after explore.
+            maxOutputChars: Math.min(budget.maxOutputChars, digest ? 11000 : 12000),
+            defaultMaxFiles: Math.min(budget.defaultMaxFiles, 2),
+            maxCharsPerFile: Math.min(budget.maxCharsPerFile, digest ? 3000 : 4500),
             includeRelationships: false,
             includeAdditionalFiles: false,
             includeCompletenessSignal: false,
@@ -402,12 +399,11 @@ function tightenExploreBudgetForQuery(budget, query, opts) {
     if (!local && !compact && hasFlow)
         return budget;
     if (!local && !compact && hasFlow === false) {
-        // Generic no-flow explore: still trim meta + file count a bit.
         return {
             ...budget,
-            maxOutputChars: Math.min(budget.maxOutputChars, 14000),
-            defaultMaxFiles: Math.min(budget.defaultMaxFiles, 3),
-            maxCharsPerFile: Math.min(budget.maxCharsPerFile, 5000),
+            maxOutputChars: Math.min(budget.maxOutputChars, digest ? 10000 : 10000),
+            defaultMaxFiles: Math.min(budget.defaultMaxFiles, 2),
+            maxCharsPerFile: Math.min(budget.maxCharsPerFile, digest ? 2800 : 4000),
             includeRelationships: false,
             includeAdditionalFiles: false,
             includeCompletenessSignal: false,
@@ -421,9 +417,9 @@ function tightenExploreBudgetForQuery(budget, query, opts) {
         || (0, query_utils_1.queryAsTypeLifecycleSurvey)(query);
     return {
         ...budget,
-        maxOutputChars: Math.min(budget.maxOutputChars, lean ? 4800 : local ? 7000 : 9000),
-        defaultMaxFiles: Math.min(budget.defaultMaxFiles, lean ? 2 : local ? 2 : 3),
-        maxCharsPerFile: Math.min(budget.maxCharsPerFile, lean ? 2200 : local ? 3500 : 4000),
+        maxOutputChars: Math.min(budget.maxOutputChars, lean ? (digest ? 5000 : 4800) : local ? (digest ? 6000 : 7000) : (digest ? 8000 : 9000)),
+        defaultMaxFiles: Math.min(budget.defaultMaxFiles, 2),
+        maxCharsPerFile: Math.min(budget.maxCharsPerFile, lean ? (digest ? 2200 : 2200) : local ? (digest ? 2800 : 3500) : (digest ? 3000 : 4000)),
         includeRelationships: false,
         includeAdditionalFiles: false,
         includeCompletenessSignal: false,
@@ -444,6 +440,14 @@ function tightenExploreBudgetForQuery(budget, query, opts) {
 function exploreLineNumbersEnabled() {
     return process.env.HOMEGRAPH_EXPLORE_LINENUMS !== '0';
 }
+/**
+ * Locator mid-lean mode (default ON): explore returns anchors + spine digests
+ * (~12K) — enough to avoid a Read storm, not a multi-file body dump.
+ * Set `HOMEGRAPH_EXPLORE_FULL_SOURCE=1` to restore the previous fatter Source.
+ */
+function exploreLocatorDigestEnabled() {
+    return process.env.HOMEGRAPH_EXPLORE_FULL_SOURCE !== '1';
+}
 /**
  * Adaptive explore sizing (default ON). `homegraph_explore` skeletonizes OFF-SPINE
  * polymorphic-sibling files — a file whose class is one of ≥3 interchangeable
@@ -840,21 +844,28 @@ exports.tools = [
     },
     {
         name: 'homegraph_explore',
-        description: 'In-repo multi-file / mechanism tool (call paths + compact line-numbered source). Required: `query`. ' +
-            'CALL FIRST for how/wired questions — pass the question or domain keywords; PascalCase names optional. ' +
-            'Also CALL FIRST (alone, no parallel Grep) for named Type/Component/Page/Dialog, Type.member, click→handler, inheritance/subtypes, ' +
-            'declaration/attribute sites, ALL_CAPS constant / field-mutex usages, path-module NAPI/exports or inter-deps, ' +
-            'and in-repo @kit/@ohos *usages/dependencies* (which files import a named export — not the SDK feature catalog). ' +
-            'On the first turn call explore alone (no parallel Grep). Prefer callers/node when one named symbol is already enough. ' +
-            'DO NOT call for topic file-lists, concept/UI-behavior with no named anchors, literal copy hunts, or SDK/@kit *feature catalogs* — those return Skip guidance. ' +
-            'Literal string/pattern hunts → Grep. ' +
-            'One explore; answer from Source + trail; treat as already Read — do not re-grep/node/read the same symbols. Busy/partial → retry same explore once.',
+        description: 'PRIMARY entry for understanding THIS repo before you edit or answer structural questions. ' +
+            'Returns call paths + compact line-numbered source for the relevant symbols. Required: `query`. ' +
+            'CALL FIRST (alone, no parallel Grep/Read) when you will change an existing codebase — pass the user task or domain keywords ' +
+            '(page/module/feature/component words); locate where to edit before writing code. Also CALL FIRST for how/wired questions, ' +
+            'named Type/Component/Page/Dialog, Type.member, click→handler, inheritance/subtypes, declaration/attribute sites, ' +
+            'ALL_CAPS constant / field-mutex usages, path-module NAPI/exports or inter-deps, and in-repo @kit/@ohos *usages/dependencies* ' +
+            '(which files import a named export — not the SDK feature catalog). PascalCase names optional when domain keywords suffice. ' +
+            'Prefer callers/node when one named symbol is already enough. ' +
+            'DO NOT call for topic file-lists with no Type/file, literal copy hunts / pure existence compares with no anchors, ' +
+            'official-docs-only asks, empty-project-from-scratch scaffolds, git history, or media/binary asset inventories — those return Skip. ' +
+            '@kit / OHOS API questions ARE in scope when the SDK API graph is available — call explore (usages or API symbols). ' +
+            'Literal string/pattern hunts → Grep; media assets → Glob; git history → git. ' +
+            'One explore; then answer or edit from Source + trail — do not re-grep/node/read the same symbols. ' +
+            'Overlapping paraphrase explores are refused (name a new Type/file/@kit to continue). ' +
+            'Busy/partial → retry ONCE with the named Next anchor or ONE narrow Grep — not a Grep/node storm '
+            + '(session refuses further explore / depth fan-out after Partial).',
         inputSchema: {
             type: 'object',
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Required. Prefer the user question or domain keywords for how/mechanism. ' +
+                    description: 'Required. For pre-edit orientation or how/mechanism: pass the user task or domain keywords (page/module/feature words). ' +
                         'For named flows, include Type / Type.member / component names. For @kit, ask usages (depend/import sites), not SDK catalogs.',
                 },
                 maxFiles: {
@@ -868,6 +879,60 @@ exports.tools = [
         },
         annotations: READ_ONLY_ANNOTATIONS,
     },
+    {
+        name: 'homegraph_usages',
+        description: 'Focused in-repo usage inventory for one named API, `.member`, ALL_CAPS constant, field, or mutex. ' +
+            'Required: `query`. Returns usage files/lines only; it does not build a general flow or source dump. ' +
+            'Use directly for a narrow where-used question; `homegraph_explore` auto-routes equivalent high-confidence queries here.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Required. Exact API/member/constant/field name, with or without where-used wording.',
+                },
+                projectPath: projectPathProperty,
+            },
+            required: ['query'],
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    },
+    {
+        name: 'homegraph_modules',
+        description: 'Focused dependency/cycle inventory for named path modules or `*common` / `*service` / `*component` / `*constants` modules. ' +
+            'Required: `query`. It does not build a general code flow or scan unrelated survey families. ' +
+            '`homegraph_explore` auto-routes equivalent high-confidence dependency questions here.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Required. Dependency/cycle question containing the exact module names or paths.',
+                },
+                projectPath: projectPathProperty,
+            },
+            required: ['query'],
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    },
+    {
+        name: 'homegraph_native',
+        description: 'Focused NAPI/native export inventory for one named path or Type. Required: `query`. ' +
+            'Returns indexed export descriptors/registration sites without a general domain file dump. ' +
+            '`homegraph_explore` auto-routes equivalent high-confidence NAPI/export questions here.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Required. NAPI/native export question containing the exact path or Type name.',
+                },
+                projectPath: projectPathProperty,
+            },
+            required: ['query'],
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    },
     {
         name: 'homegraph_status',
         description: 'Index health check (files / nodes / edges). No required args when a default project is loaded. Skip unless debugging.',
@@ -1063,12 +1128,150 @@ function getStaticTools() {
     const allow = new Set(raw.split(',').map(s => s.trim().replace(/^homegraph_/, '').replace(/^homegraph_/, '')).filter(Boolean));
     return allow.size ? exports.tools.filter(t => allow.has(t.name.replace(/^homegraph_/, ''))) : exports.tools;
 }
+/** Prose that reads like an identifier but never names a symbol worth scanning. */
+const BARE_USAGE_STOPWORDS = new Set([
+    'class', 'method', 'function', 'interface', 'module', 'import', 'export', 'value',
+    'file', 'files', 'code', 'usage', 'usages', 'where', 'which', 'what', 'when',
+    'call', 'calls', 'called', 'caller', 'callers', 'used', 'uses', 'using',
+    'true', 'false', 'null', 'undefined', 'this', 'return', 'const', 'type',
+    'string', 'number', 'boolean', 'object', 'array', 'void', 'async', 'await',
+]);
+/** Identifier-shaped tokens from a bare symbol bag. */
+function extractBareUsageSymbols(query) {
+    const out = [];
+    const seen = new Set();
+    const re = /\b([A-Z][A-Za-z0-9]{3,}(?:\.[A-Za-z_]\w*)?|[A-Z][A-Z0-9_]{3,}|[a-z]+[A-Z]\w{2,}(?:\.[A-Za-z_]\w*)?)\b/g;
+    for (const m of query.matchAll(re)) {
+        const tok = m[1];
+        const key = tok.toLowerCase();
+        if (seen.has(key) || BARE_USAGE_STOPWORDS.has(key))
+            continue;
+        seen.add(key);
+        out.push(tok);
+    }
+    return out;
+}
+/** Wording that asks how something works — never a plain usage inventory. */
+const FLOW_INTENT_RE = /如何|怎[么样]|机制|流程|原理|为什么|为何|架构|生命周期|时序|调用链|关系|\b(how|why|flow|mechanism|lifecycle|architecture|sequence|pipeline|between|implement|implementation)\b/i;
+/** Action-shaped identifiers are probably call-flow anchors, not inventories. */
+const ACTION_SEGMENTS = new Set([
+    'trigger', 'callback', 'handler', 'listener', 'observer', 'dispatch', 'emit',
+    'notify', 'render', 'draw', 'init', 'start', 'stop', 'update', 'refresh',
+    'subscribe', 'publish', 'invoke', 'execute', 'run', 'process', 'handle',
+    'post', 'send', 'receive', 'load', 'save', 'open', 'close',
+]);
+function identifierSegments(token) {
+    return token
+        .replace(/[._]/g, ' ')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+}
+/**
+ * True only for a short bag of ALL_CAPS constants. Type/method bags remain on
+ * explore-flow because routing those to usages would discard call paths.
+ */
+function queryAsBareSymbolInventory(query) {
+    if (process.env.HOMEGRAPH_EXPLORE_SHAPE_ROUTING === '0')
+        return false;
+    const tokens = String(query || '').split(/[\s,、，]+/).filter(Boolean);
+    if (tokens.length === 0 || tokens.length > 6)
+        return false;
+    if (FLOW_INTENT_RE.test(query))
+        return false;
+    if (tokens.some((t) => identifierSegments(t).some((s) => ACTION_SEGMENTS.has(s))))
+        return false;
+    return tokens.every((t) => /^[A-Z][A-Z0-9_]{3,}$/.test(t));
+}
 /**
  * Tool handler that executes tools against a HomeGraph instance
  *
  * Supports cross-project queries via the projectPath parameter.
  * Other projects are opened on-demand and cached for performance.
  */
+const ANSWER_NOW_TOKEN = /\bANSWER NOW\b/gi;
+/** Whether one ANSWER NOW occurrence is postponed/negated rather than a stop directive. */
+function isNegatedAnswerNowAt(text, index) {
+    const prefix = text
+        .slice(Math.max(0, index - 96), index)
+        .replace(/[*_`]/g, '')
+        .replace(/\s+/g, ' ');
+    return /(?:\b(?:do|should|must|can)\s+not|\bcannot|\bnever|\bbefore|\buntil|\bnot)\s+(?:\S+\s+){0,3}$/i
+        .test(prefix);
+}
+/** True only for a positive instruction to stop and answer, not "do not/before ANSWER NOW". */
+function hasPositiveAnswerNowDirective(text) {
+    const answerNow = new RegExp(ANSWER_NOW_TOKEN.source, ANSWER_NOW_TOKEN.flags);
+    for (let match = answerNow.exec(text); match; match = answerNow.exec(text)) {
+        if (!isNegatedAnswerNowAt(text, match.index))
+            return true;
+    }
+    return false;
+}
+function stripPositiveAnswerNowFromLine(line) {
+    let changed = false;
+    let out = line.replace(/\*\*[^*\n]*\bANSWER NOW\b[^*\n]*\*\*/gi, (span, offset, source) => {
+        const tokenOffset = span.search(/\bANSWER NOW\b/i);
+        if (tokenOffset < 0 || isNegatedAnswerNowAt(source, offset + tokenOffset))
+            return span;
+        changed = true;
+        return '';
+    });
+    out = out.replace(ANSWER_NOW_TOKEN, (token, offset, source) => {
+        if (isNegatedAnswerNowAt(source, offset))
+            return token;
+        changed = true;
+        return '';
+    });
+    if (!changed)
+        return { text: line, changed: false };
+    // A positive close often carries a matching search prohibition. Once the
+    // whole response is Partial, that prohibition is contradictory too.
+    out = out
+        .replace(/\s*(?:[,;—-]\s*)?(?:and\s+)?do\s+\*{0,2}not\*{0,2}\s+(?:(?:re-)?(?:Read|Grep|Glob)|`?homegraph_(?:search|explore|node|callers|callees)`?)[^.;\n]*/gi, '')
+        .replace(/\s*(?:[,;—-]\s*)?no\s+(?:glob|grep|read|search|explore)(?:\s*\/\s*(?:glob|grep|read|search|explore))*\s+needed\b[^.;\n]*/gi, '')
+        .replace(/\(\s*[,;—-]*\s*\)/g, '')
+        .replace(/\s{2,}/g, ' ')
+        .replace(/\s+([.;,])/g, '$1')
+        .replace(/^(>\s*)[\s.;,—-]+/, '$1')
+        .trimEnd();
+    return { text: out, changed: true };
+}
+/**
+ * Drop stop-searching directives from an output that also declares itself partial.
+ *
+ * Section builders each append their own footer and cannot see their siblings, so
+ * one output can carry both `**Partial locator**` ("these are anchors, keep
+ * looking") and `**ANSWER NOW**` ("stop, do not Grep"). Measured on a 54-question
+ * run: 21 such outputs across 17 of 48 questions. Whichever the agent obeys, the
+ * other was wrong — it either answers from an inventory the tool just called
+ * incomplete, or it keeps searching against an explicit prohibition.
+ *
+ * Partial wins: an under-informed agent that keeps looking recovers, while one
+ * that stops on a partial answer cannot. Negated mentions (`do **not** ANSWER
+ * NOW`) are the correct pairing and are preserved.
+ */
+function reconcilePartialAnswerNow(text) {
+    if (!/\*\*Partial locator\*\*/i.test(text))
+        return text;
+    let changed = false;
+    const out = text
+        .split('\n')
+        .map((line) => {
+        if (!/ANSWER NOW/i.test(line))
+            return line;
+        const stripped = stripPositiveAnswerNowFromLine(line);
+        if (stripped.changed)
+            changed = true;
+        return stripped.text;
+    })
+        .filter((line) => line.trim() !== '>')
+        .join('\n');
+    if (!changed)
+        return text;
+    return `${out}\n\n> This survey is a **Partial locator**: the sections above are anchors, not a closed answer. Continue with the narrower lookup named above, or a text search, before answering.`;
+}
 class ToolHandler {
     cg;
     // Cache of opened HomeGraph instances for cross-project queries
@@ -1665,11 +1868,6 @@ class ToolHandler {
                 this.catchUpGate = null;
                 await this.awaitCatchUpGate(gate);
             }
-            // Hard process RSS ceiling — any tool/path that already pushed us over must
-            // stop with success-shaped Partial (never OOM / multi-GB growth).
-            if ((0, memory_budget_1.isOverRssBudget)()) {
-                return (0, memory_budget_1.rssBudgetPartialResult)(toolName);
-            }
             // Honor the optional tool allowlist (HOMEGRAPH_MCP_TOOLS): a trimmed
             // surface rejects ablated tools defensively even if a client cached them.
             if (!this.isToolAllowed(toolName)) {
@@ -1706,6 +1904,16 @@ class ToolHandler {
                     }
                 }
             }
+            // Post-Partial depth fuse: Partial→node×N is the same failure class as
+            // explore×N. Shape-driven only — one depth call, then refuse.
+            if (sessionState
+                && (toolName === 'homegraph_node'
+                    || toolName === 'homegraph_callers'
+                    || toolName === 'homegraph_callees')) {
+                const depthRefuse = this.tryDepthToolFuse(toolName, args, sessionState);
+                if (depthRefuse)
+                    return depthRefuse;
+            }
             // Session-tracked explore must not hit the MCP query cache: a cache hit
             // would re-serve the first call's full source and defeat CG-18 dedup.
             const skipCacheForSession = toolName === 'homegraph_explore' && !!sessionState;
@@ -1756,18 +1964,27 @@ class ToolHandler {
                     try {
                         const cgFast = this.getHomeGraph(projectPath);
                         const rootFast = cgFast.getProjectRoot();
-                        const fast = (toolName === 'homegraph_explore' || toolName === 'homegraph_search'
-                            ? this.tryFastInventoryExplore(cgFast, q, rootFast)
+                        const fast = (toolName === 'homegraph_explore'
+                            ? this.trySpecializedExploreRoute(cgFast, q, rootFast)
                             : null)
+                            ?? (toolName === 'homegraph_explore' || toolName === 'homegraph_search'
+                                ? this.tryFastInventoryExplore(cgFast, q, rootFast)
+                                : null)
                             ?? (toolName === 'homegraph_explore' || toolName === 'homegraph_search'
                                 ? this.tryLightMechanismExplore(cgFast, q, rootFast)
                                 : null)
                             ?? this.tryCompactLocalSymbolExplore(cgFast, q, rootFast);
                         if (fast) {
-                            if (cacheEnabled && cacheKey && cacheQueries && cacheIndex && !fast.isError) {
-                                cacheIndex.setEntry(cacheQueries, cacheKey, toolName, fast);
+                            // Fast explore must still file Partial/ANSWER meta into the session
+                            // so explore + depth fuses see it (textResult-only paths used to skip).
+                            let served = fast;
+                            if (toolName === 'homegraph_explore' && sessionState) {
+                                served = this.takeExploreEmission(this.ensureExploreEmission(fast, rootFast, q), sessionState);
+                            }
+                            if (cacheEnabled && cacheKey && cacheQueries && cacheIndex && !served.isError) {
+                                cacheIndex.setEntry(cacheQueries, cacheKey, toolName, served);
                             }
-                            const withWorktree = this.withWorktreeNotice(fast, projectPath);
+                            const withWorktree = this.withWorktreeNotice(served, projectPath);
                             return this.withStalenessNotice(withWorktree, projectPath);
                         }
                     }
@@ -1786,6 +2003,13 @@ class ToolHandler {
             // `-32001`). Fast-path surveys run inside the worker via executeReadTool.
             const raw = await this.runReadToolWithDeadline(toolName, dispatchArgs);
             const result = this.takeExploreEmission(raw, sessionState);
+            if (sessionState
+                && !result.isError
+                && (toolName === 'homegraph_node'
+                    || toolName === 'homegraph_callers'
+                    || toolName === 'homegraph_callees')) {
+                this.noteDepthToolUse(args, sessionState);
+            }
             if (cacheEnabled && cacheKey && cacheQueries && cacheIndex && !result.isError) {
                 cacheIndex.setEntry(cacheQueries, cacheKey, toolName, result);
             }
@@ -1832,6 +2056,43 @@ class ToolHandler {
         }
         return copy;
     }
+    /**
+     * After a counted Partial explore, refuse further `node` / callers / callees
+     * once the session's one allowed depth drill is spent.
+     */
+    tryDepthToolFuse(toolName, args, sessionState) {
+        try {
+            const cg = this.getHomeGraph(args.projectPath);
+            const root = cg.getProjectRoot();
+            const decision = (0, explore_repeat_guard_1.decideDepthToolFuse)(sessionState.forProject(root), sessionState.depthToolCount(root), toolName);
+            if (!decision.refuse)
+                return null;
+            const hint = typeof args.symbol === 'string'
+                ? args.symbol
+                : typeof args.file === 'string'
+                    ? args.file
+                    : undefined;
+            return this.textResult((0, explore_repeat_guard_1.formatDepthToolRefuse)(decision, toolName, hint));
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Count a successful depth-tool call when the latest explore was Partial. */
+    noteDepthToolUse(args, sessionState) {
+        try {
+            const cg = this.getHomeGraph(args.projectPath);
+            const root = cg.getProjectRoot();
+            const prior = sessionState.forProject(root);
+            const last = prior?.calls.length
+                ? [...prior.calls].reverse().find((c) => (c.responseBytes || 0) >= 400)
+                : undefined;
+            if (!last?.partial)
+                return;
+            sessionState.recordDepthTool(root);
+        }
+        catch { /* bookkeeping only */ }
+    }
     /**
      * Record an explore call's emission into the caller's session state and strip
      * it from the result (CG-17).
@@ -1849,6 +2110,25 @@ class ToolHandler {
         delete result[explore_session_state_1.EXPLORE_EMISSION_KEY];
         if (sessionState) {
             try {
+                const prior = sessionState.forProject(emission.projectRoot);
+                const priorPartials = (prior?.calls ?? []).filter((c) => c.partial === true && (c.responseBytes || 0) >= 400);
+                const metaPartial = emission.partial === true
+                    || (emission.partial === undefined
+                        && (0, explore_repeat_guard_1.inferExplorePartialMeta)(result.content?.[0]?.text ?? '').partial);
+                if (metaPartial && priorPartials.length >= 1) {
+                    const text = result.content?.[0]?.text ?? '';
+                    if (text && !/Second Partial — stop HomeGraph/i.test(text)) {
+                        const stop = (0, explore_repeat_guard_1.formatSecondPartialStopFooter)(emission.nextAnchor);
+                        result = {
+                            ...result,
+                            content: [
+                                { type: 'text', text: text + stop },
+                                ...result.content.slice(1),
+                            ],
+                        };
+                        emission.responseBytes = (result.content[0]?.text ?? text).length;
+                    }
+                }
                 sessionState.record(emission);
             }
             catch { /* bookkeeping only — never fail a served call */ }
@@ -1881,7 +2161,7 @@ class ToolHandler {
                 return this.queryPool.run(toolName, args, {
                     // Static Partial only — never DB/FTS on the soft-timeout callback
                     // (any sync work here can freeze the MCP transport → empty -32001).
-                    onSoftTimeout: () => this.deadlineBusyResult(deadlineMs),
+                    onSoftTimeout: () => this.deadlineBusyResult(deadlineMs, args),
                 });
             }
             return (async () => {
@@ -1894,7 +2174,7 @@ class ToolHandler {
             // Keep this timer ref'd so a blocked sync stretch still flushes Partial
             // once the event loop runs again — do not call wrapPartialBusyResult here.
             timer = setTimeout(() => {
-                resolve(this.deadlineBusyResult(deadlineMs));
+                resolve(this.deadlineBusyResult(deadlineMs, args));
             }, deadlineMs);
         });
         try {
@@ -1905,13 +2185,15 @@ class ToolHandler {
                 clearTimeout(timer);
         }
     }
-    /** Success-shaped busy note — no DB, never blocks the transport. */
-    deadlineBusyResult(deadlineMs) {
+    /** Success-shaped busy note — anchors from query when present; no DB. */
+    deadlineBusyResult(deadlineMs, args) {
         const secs = Math.max(1, Math.round(deadlineMs / 1000));
-        return this.textResult(`⚠️ **Partial result** — HomeGraph hit its ${secs}s response deadline / is busy ` +
-            `(MCP clients typically kill the call at ~60s with an empty timeout). ` +
-            `This is NOT an error. Retry ONE \`homegraph_explore\` with concrete symbol/file names from the question — ` +
-            `do not fire search+explore or node+callers+callees in parallel, and do not grep/read symbols you already named.`);
+        const query = typeof args?.query === 'string' ? args.query : undefined;
+        return this.textResult((0, explore_repeat_guard_1.formatPartialExploreGuidance)({
+            seconds: secs,
+            query,
+            why: `HomeGraph hit its ${secs}s response deadline / is busy (MCP clients typically kill the call at ~60s with an empty timeout)`,
+        }));
     }
     /**
      * Run a single read tool to completion and return its raw {@link ToolResult},
@@ -1965,6 +2247,9 @@ class ToolHandler {
             case 'homegraph_impact': return await this.handleImpact(args);
             case 'homegraph_diff_impact': return await this.handleDiffImpact(args);
             case 'homegraph_explore': return await this.handleExplore(args);
+            case 'homegraph_usages': return await this.handleSpecializedUsages(args);
+            case 'homegraph_modules': return await this.handleSpecializedModules(args);
+            case 'homegraph_native': return await this.handleSpecializedNative(args);
             case 'homegraph_node': return await this.handleNode(args);
             case 'homegraph_files': return await this.handleFiles(args);
             case 'homegraph_arkui_migrate': return await this.handleArkuiMigrate(args);
@@ -1987,6 +2272,17 @@ class ToolHandler {
         // getProjectRoot) must fall through to FTS search rather than error.
         try {
             const projectRoot = cg.getProjectRoot();
+            // Bare PascalCase type search — agents almost always fan out callers next;
+            // route to caller inventory instead of FTS → node×N.
+            if ((0, query_utils_1.queryIsTypeNameFocus)(query)) {
+                const types = (0, query_utils_1.extractTypeNamesFromQuery)(query);
+                if (types.length === 1) {
+                    const callerQ = `${types[0]} 哪些方法被外部调用`;
+                    const callerRedirect = this.tryFastInventoryExplore(cg, callerQ, projectRoot);
+                    if (callerRedirect)
+                        return callerRedirect;
+                }
+            }
             if ((0, query_utils_1.queryShouldPreferExploreOverSearch)(query)) {
                 const exploreRedirect = this.tryFastInventoryExplore(cg, query, projectRoot)
                     ?? this.tryLightMechanismExplore(cg, query, projectRoot)
@@ -2090,8 +2386,6 @@ class ToolHandler {
             const callers = [];
             const labels = new Map();
             for (const node of defNodes) {
-                if ((0, memory_budget_1.isOverRssBudget)())
-                    break;
                 for (const c of cg.getCallers(node.id)) {
                     if (!seen.has(c.node.id)) {
                         seen.add(c.node.id);
@@ -2130,7 +2424,8 @@ class ToolHandler {
                 + includeBlock
                 + '\n\n> Caller listing complete — answer from this list'
                 + (includeBlock ? ' + include/import visibility' : '')
-                + '; no read/grep needed.'
+                + '; do not re-Grep/Read these call sites.'
+                + '\n> For **all methods of a Type**, prefer one `homegraph_explore` with the Type + “哪些方法被调用” — do **not** fan out `homegraph_callers` per method.'
                 + '\n> If another type\'s visibility matters, pass **both** names to `homegraph_explore` (not callers alone).'
                 + note + filterNote;
             return this.textResult(this.truncateOutput(formatted));
@@ -2138,23 +2433,50 @@ class ToolHandler {
         // Multiple DISTINCT definitions (#764): one section per definition so an
         // agent never mistakes one app's callers for another's. Narrow with
         // `file` to focus a single definition.
+        // Hard stop when the name is still massively ambiguous — dumping dozens of
+        // definition sections is a token bomb and teaches a Grep/Read storm.
+        const MAX_CALLER_DEF_GROUPS = 8;
+        if (groups.length > MAX_CALLER_DEF_GROUPS) {
+            const sample = groups.slice(0, MAX_CALLER_DEF_GROUPS).map((g) => {
+                const h = g[0];
+                return `- \`${h.qualifiedName || h.name}\` (${h.kind}) — \`${h.filePath}:${h.startLine || '?'}\``;
+            });
+            return this.textResult([
+                `**Callers of ${symbol} — ${groups.length} distinct definitions (too ambiguous to expand).**`,
+                '',
+                'Re-call `homegraph_callers` with `file` set to one definition path (or use `homegraph_explore` with the owning Type name). Do **not** Grep/Read the whole repo.',
+                '',
+                'Sample definitions:',
+                ...sample,
+                groups.length > MAX_CALLER_DEF_GROUPS
+                    ? `- … +${groups.length - MAX_CALLER_DEF_GROUPS} more`
+                    : '',
+            ].filter(Boolean).join('\n') + filterNote);
+        }
         const lines = [
             `**Callers of ${symbol} — ${groups.length} distinct definitions (narrow with \`file\`)**`,
         ];
+        let anyCallers = false;
         for (const group of groups) {
             const { callers, labels } = collect(group);
             lines.push('', this.definitionHeading(group));
             if (callers.length === 0) {
-                lines.push('- (no callers)');
+                lines.push('- (no callers indexed)');
                 continue;
             }
+            anyCallers = true;
             for (const node of callers.slice(0, limit)) {
                 const location = node.startLine ? `:${node.startLine}` : '';
                 const label = labels.get(node.id);
                 lines.push(`- ${node.name} (${node.kind}) - ${node.filePath}${location}${label ? ` — via ${label}` : ''}`);
             }
         }
-        return this.textResult(this.truncateOutput(lines.join('\n') + filterNote + '\n\n> Caller listing complete — answer from this list; no read/grep needed.'));
+        const footer = anyCallers
+            ? '\n\n> Caller listing complete — answer from this list; no read/grep needed.'
+            : '\n\n> **No call edges indexed** for these definitions (common for callbacks / bus registration). '
+                + 'HomeGraph located the symbol(s) above — a **narrow** Grep for the registration site is OK; '
+                + 'do not open a repo-wide Grep storm. Prefer `homegraph_explore` with a concrete registrar Type if known.';
+        return this.textResult(this.truncateOutput(lines.join('\n') + filterNote + footer));
     }
     /**
      * Handle homegraph_callees
@@ -2212,6 +2534,22 @@ class ToolHandler {
             return this.textResult(this.truncateOutput(formatted));
         }
         // Multiple DISTINCT definitions (#764): per-definition sections.
+        const MAX_CALLEE_DEF_GROUPS = 8;
+        if (groups.length > MAX_CALLEE_DEF_GROUPS) {
+            const sample = groups.slice(0, MAX_CALLEE_DEF_GROUPS).map((g) => {
+                const h = g[0];
+                return `- \`${h.qualifiedName || h.name}\` (${h.kind}) — \`${h.filePath}:${h.startLine || '?'}\``;
+            });
+            return this.textResult([
+                `**Callees of ${symbol} — ${groups.length} distinct definitions (too ambiguous to expand).**`,
+                '',
+                'Re-call `homegraph_callees` with `file` set to one definition path (or `homegraph_explore` with the owning Type). Do **not** Grep/Read the whole repo.',
+                '',
+                'Sample definitions:',
+                ...sample,
+                `- … +${groups.length - MAX_CALLEE_DEF_GROUPS} more`,
+            ].join('\n') + filterNote);
+        }
         const lines = [
             `**Callees of ${symbol} — ${groups.length} distinct definitions (narrow with \`file\`)**`,
         ];
@@ -3141,12 +3479,19 @@ class ToolHandler {
     buildImportSitesSection(cg, query, projectRoot) {
         const kitTerms = (0, query_utils_1.extractKitModuleNamesFromQuery)(query);
         const depSymbols = (0, query_utils_1.extractDependencySymbolsFromQuery)(query).filter((s) => !(0, query_utils_1.isMemberLikeIdentifier)(s) && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(s.toLowerCase()));
-        const focusExports = [
+        // Named kit export (taskpool) stays; NL leftovers must not become focusExports.
+        // When a *Kit is named and there is no real submodule, search by kit path only.
+        const kitSubmodules = (0, query_utils_1.extractKitSubmoduleNamesFromQuery)(query);
+        let focusExports = [
             ...new Set([
-                ...(0, query_utils_1.extractKitSubmoduleNamesFromQuery)(query),
+                ...kitSubmodules,
                 ...depSymbols.filter((s) => s.length >= 4),
             ]),
         ];
+        if (kitTerms.length > 0 && kitSubmodules.length === 0) {
+            // Drop non-distinctive leftovers; kit module path is the inventory key.
+            focusExports = focusExports.filter((s) => (0, query_utils_1.isDistinctiveIdentifier)(s) && s.length >= 5);
+        }
         const kitSearchTerms = (0, query_utils_1.extractImportSearchTerms)(query);
         // Named export/API + kit (or usage-survey intent) → return the full matching list.
         const completeInventory = focusExports.length > 0
@@ -3466,14 +3811,13 @@ class ToolHandler {
     /**
      * Multi-module / circular dependency survey — lean cycle list, not an import flood.
      */
-    buildModuleDependencySurveySection(cg, query) {
-        // Prefer leaf module tokens (`launchercommon`) over shared parents (`staticcommon`)
-        // — parent matches flood unrelated windowscene cycles.
+    extractFocusedModuleNames(query) {
         const leafModules = new Set();
         for (const p of (query.match(/\b[A-Za-z][\w]*(?:common|service|component|constants)\b/gi) ?? [])) {
             const low = p.toLowerCase();
-            if (!/^(?:static|feature|product|base|common)$/i.test(low))
+            if (!/^(?:static|staticcommon|feature|product|base|basecommon|common)$/i.test(low)) {
                 leafModules.add(low);
+            }
         }
         for (const seg of query.match(/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)+/g) ?? []) {
             const leaf = seg.split(/[/\\]/).pop()?.toLowerCase();
@@ -3481,6 +3825,12 @@ class ToolHandler {
                 leafModules.add(leaf);
             }
         }
+        return leafModules;
+    }
+    buildModuleDependencySurveySection(cg, query) {
+        // Prefer leaf module tokens (`launchercommon`) over shared parents (`staticcommon`)
+        // — parent matches flood unrelated windowscene cycles.
+        const leafModules = this.extractFocusedModuleNames(query);
         if (leafModules.size === 0)
             return { section: '', hitCount: 0 };
         const rel = (p) => p.replace(/\\/g, '/');
@@ -3533,6 +3883,155 @@ class ToolHandler {
         lines.push('');
         return { section: lines.join('\n'), hitCount: matchedCycles.length };
     }
+    /** Bounded manifest-only dependency graph for modules named in the query. */
+    buildFocusedModuleManifestSection(projectRoot, query) {
+        const moduleNames = this.extractFocusedModuleNames(query);
+        if (moduleNames.size === 0)
+            return { section: '', manifestCount: 0, cycleCount: 0 };
+        const skipDirs = new Set([
+            'node_modules', 'oh_modules', '.git', '.homegraph', '.hvigor', '.preview',
+            'build', 'dist', 'out', 'test', 'ohosTest',
+        ]);
+        const queue = [{ rel: '', depth: 0 }];
+        const manifests = new Map();
+        const linterFiles = [];
+        const asksDetection = /构建系统|如何检测|怎么检测|检测方式|linter|build\s+system|how.{0,24}detect/i.test(query);
+        let visited = 0;
+        let cursor = 0;
+        while (cursor < queue.length && visited < 8000) {
+            const { rel, depth } = queue[cursor++];
+            visited++;
+            const abs = (0, path_1.resolve)(projectRoot, rel);
+            let entries;
+            try {
+                entries = (0, fs_1.readdirSync)(abs, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            const leaf = rel.split('/').pop()?.toLowerCase() ?? '';
+            if (moduleNames.has(leaf) && entries.some((entry) => entry.isFile() && entry.name === 'oh-package.json5')) {
+                const paths = manifests.get(leaf) ?? [];
+                if (paths.length < 3)
+                    paths.push(rel ? `${rel}/oh-package.json5` : 'oh-package.json5');
+                manifests.set(leaf, paths);
+            }
+            for (const entry of entries) {
+                const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+                if (entry.isFile()) {
+                    if (/^(?:code-)?linter.*\.json5?$/i.test(entry.name) && linterFiles.length < 8) {
+                        linterFiles.push(childRel);
+                    }
+                    continue;
+                }
+                if (!entry.isDirectory() || depth >= 6)
+                    continue;
+                if (entry.name.startsWith('.') || skipDirs.has(entry.name))
+                    continue;
+                queue.push({ rel: childRel, depth: depth + 1 });
+            }
+            if (manifests.size === moduleNames.size && (!asksDetection || linterFiles.length > 0))
+                break;
+        }
+        if (manifests.size === 0)
+            return { section: '', manifestCount: 0, cycleCount: 0 };
+        const normalizeDependency = (name) => {
+            const noProtocol = name.replace(/^file:/i, '').replace(/\\/g, '/');
+            return noProtocol.split('/').filter(Boolean).pop()?.toLowerCase() ?? '';
+        };
+        const graph = new Map();
+        const rows = [];
+        for (const moduleName of [...moduleNames].sort()) {
+            const manifestPaths = manifests.get(moduleName) ?? [];
+            if (manifestPaths.length === 0) {
+                rows.push(`- \`${moduleName}\` — manifest not found within the bounded project scan`);
+                graph.set(moduleName, new Set());
+                continue;
+            }
+            const manifestRel = manifestPaths[0];
+            let parsed;
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                parsed = require('jsonc-parser').parse((0, fs_1.readFileSync)((0, path_1.resolve)(projectRoot, manifestRel), 'utf-8'));
+            }
+            catch {
+                rows.push(`- \`${moduleName}\` — could not parse \`${manifestRel}\``);
+                graph.set(moduleName, new Set());
+                continue;
+            }
+            const deps = parsed?.dependencies;
+            const declared = deps && typeof deps === 'object' ? Object.entries(deps) : [];
+            const namedDeps = new Set();
+            for (const [depName, depValue] of declared) {
+                const candidates = [normalizeDependency(depName)];
+                if (typeof depValue === 'string')
+                    candidates.push(normalizeDependency(depValue));
+                for (const candidate of candidates) {
+                    if (candidate !== moduleName && moduleNames.has(candidate))
+                        namedDeps.add(candidate);
+                }
+            }
+            graph.set(moduleName, namedDeps);
+            const target = namedDeps.size > 0
+                ? [...namedDeps].sort().map((name) => `\`${name}\``).join(', ')
+                : '(none among the named modules)';
+            rows.push(`- \`${moduleName}\` → ${target} — \`${manifestRel}\` (${declared.length} declared dependencies total)`);
+        }
+        const cycles = new Set();
+        const visit = (start, current, path, seen) => {
+            for (const next of graph.get(current) ?? []) {
+                if (next === start && path.length > 1) {
+                    const core = path;
+                    const rotations = core.map((_, index) => {
+                        const rotated = [...core.slice(index), ...core.slice(0, index)];
+                        return [...rotated, rotated[0]].join(' -> ');
+                    });
+                    cycles.add(rotations.sort()[0]);
+                    continue;
+                }
+                if (seen.has(next))
+                    continue;
+                visit(start, next, [...path, next], new Set([...seen, next]));
+            }
+        };
+        for (const moduleName of graph.keys())
+            visit(moduleName, moduleName, [moduleName], new Set([moduleName]));
+        const lines = [
+            '**Named module manifest dependencies**', '', ...rows, '',
+            cycles.size > 0
+                ? `Detected **${cycles.size}** cycle(s) among the named modules:`
+                : 'Detected **no cycle** among the named modules.',
+        ];
+        for (const cycle of cycles)
+            lines.push(`- \`${cycle}\``);
+        if (asksDetection) {
+            lines.push('', '**Build / linter cycle checks**', '');
+            let matched = 0;
+            for (const rel of linterFiles) {
+                let fileLines = [];
+                try {
+                    fileLines = (0, fs_1.readFileSync)((0, path_1.resolve)(projectRoot, rel), 'utf-8').split('\n');
+                }
+                catch {
+                    continue;
+                }
+                for (let i = 0; i < fileLines.length; i++) {
+                    const line = fileLines[i] ?? '';
+                    if (!/no-cycle|circular|cycle/i.test(line))
+                        continue;
+                    lines.push(`- \`${rel}:${i + 1}\` — \`${line.trim().slice(0, 140)}\``);
+                    if (++matched >= 12)
+                        break;
+                }
+                if (matched >= 12)
+                    break;
+            }
+            if (matched === 0)
+                lines.push('- No explicit cycle-check rule was found in the bounded linter-config scan.');
+        }
+        lines.push('');
+        return { section: lines.join('\n'), manifestCount: manifests.size, cycleCount: cycles.size };
+    }
     /**
      * Path-module / named-Type NAPI export surface — not a 50-file domain dump.
      */
@@ -3544,7 +4043,7 @@ class ToolHandler {
             ...types.map((t) => t.toLowerCase()),
         ].filter((n) => n.length >= 4);
         if (needles.length === 0)
-            return { section: '', hitCount: 0 };
+            return { section: '', hitCount: 0, shellOnly: false };
         const rel = (p) => p.replace(/\\/g, '/');
         const inScope = (fp) => {
             const low = rel(fp).toLowerCase();
@@ -3583,12 +4082,16 @@ class ToolHandler {
                 const fileLines = content.split('\n');
                 for (let i = 0; i < fileLines.length; i++) {
                     const line = fileLines[i] ?? '';
-                    // napi_define_function / exports / Descriptor { "foo", … }
+                    // napi_define_function / properties table rows:
+                    //   {"draw", nullptr, PluginManager::NapiDraw, ...}
+                    // (qualified C++ method names — `\w+` alone misses `::`)
                     const m = line.match(/napi_define_(?:function|property)\s*\([^,]+,\s*["']([\w]+)["']/i)
-                        || line.match(/\{\s*["']([\w]+)["']\s*,\s*(?:nullptr|NULL)?\s*,\s*\w+/i)
+                        || line.match(/\{\s*["']([\w]+)["']\s*,\s*(?:nullptr|NULL)\s*,\s*[\w:]+/i)
                         || line.match(/\.?(?:exports|export)\s*[:=].*["']([\w]+)["']/i);
                     if (!m?.[1] || m[1].length < 2)
                         continue;
+                    if (/^(?:nullptr|NULL|napi_default|env|exports)$/i.test(m[1]))
+                        continue;
                     const key = `${m[1]}:${rel(r.node.filePath)}`;
                     if (seen.has(key))
                         continue;
@@ -3600,7 +4103,7 @@ class ToolHandler {
                         snippet: line.trim().slice(0, 100),
                     });
                 }
-                // Also list Export / Init method nodes in-scope.
+                // Also list Export / Init method nodes in-scope (entry shells — not the API surface).
                 if (/^(?:Export|Init|NapiInit)$/i.test(r.node.name)) {
                     const key = `fn:${r.node.name}:${rel(r.node.filePath)}`;
                     if (!seen.has(key)) {
@@ -3615,24 +4118,34 @@ class ToolHandler {
                 }
             }
         }
+        const apiExports = exports.filter((e) => !/^(?:Export|Init|NapiInit)$/i.test(e.name));
+        const shellOnly = apiExports.length === 0 && exports.length > 0;
         const lines = [
             '**NAPI / native export survey**',
             '',
-            `> In-repo NAPI surface for \`${needles.slice(0, 4).join('`, `')}\`. **ANSWER NOW** — do not Grep \`napi_define\` again.`,
+            shellOnly
+                ? `> Found Init/Export shells under \`${needles.slice(0, 4).join('`, `')}\` but no \`napi_define_properties\` / descriptor API names. `
+                    + '**Partial locator** — Read the Init body / \`napi_property_descriptor\` table next; do **not** ANSWER NOW as a full API list.'
+                : `> In-repo NAPI surface for \`${needles.slice(0, 4).join('`, `')}\`. **ANSWER NOW** — do not Grep \`napi_define\` again.`,
             '',
         ];
         if (exports.length === 0) {
             lines.push('- No `napi_define_*` / Export descriptors found under the named path/Type.');
             lines.push('');
-            return { section: lines.join('\n'), hitCount: 0 };
+            return { section: lines.join('\n'), hitCount: 0, shellOnly: false };
         }
-        for (const e of exports.slice(0, 30)) {
+        const ranked = shellOnly ? exports : (apiExports.length > 0 ? apiExports : exports);
+        for (const e of ranked.slice(0, 30)) {
             lines.push(`- \`${e.name}\` — \`${e.file}:${e.line}\`  \`${e.snippet}\``);
         }
-        if (exports.length > 30)
-            lines.push(`- … and ${exports.length - 30} more`);
+        if (ranked.length > 30)
+            lines.push(`- … and ${ranked.length - 30} more`);
         lines.push('');
-        return { section: lines.join('\n'), hitCount: Math.min(exports.length, 30) };
+        return {
+            section: lines.join('\n'),
+            hitCount: Math.min(ranked.length, 30),
+            shellOnly,
+        };
     }
     /**
      * Named `.d.ts` wrap — where the basename is imported / called in-repo.
@@ -3779,7 +4292,7 @@ class ToolHandler {
                     hits.set(fp, prev);
                     matched = true;
                 }
-                if (!matched && /Toggle|Switch|Hotspot|Manager/i.test(r.node.name)) {
+                if (!matched && /Toggle|Switch|Manager/i.test(r.node.name)) {
                     hits.set(fp, {
                         lines: [r.node.startLine],
                         snippet: (r.node.signature || r.node.name).slice(0, 100),
@@ -3811,28 +4324,59 @@ class ToolHandler {
     }
     buildDataSourceSection(cg, query) {
         const anchors = (0, query_utils_1.extractTypeNamesFromQuery)(query).filter((n) => /Manager|Service|Handler|Store|Provider|Controller/i.test(n));
-        if (anchors.length === 0)
-            return { section: '', edgeCount: 0 };
+        if (anchors.length === 0) {
+            return { section: '', edgeCount: 0, sdkImportCount: 0, strongCount: 0 };
+        }
         const rel = (p) => p.replace(/\\/g, '/');
-        // Prefer system/SDK / service APIs — not local UI helpers (getBadgeOffsetX).
-        const SERVICE_RE = /notification|@ohos|ans|subscribe|publish|bundle|ability|vibrator|telephony|NumBadge|notificationManager|badgeManager|wantAgent|distributed|account|osAccount|AppAccount|distributedAccount|userId|getOsAccount/i;
+        // ArkTS anonymous methods (`%AM0$foo`) are graph-internal — never "system services".
+        const isAnonName = (n) => /^%AM\d+/i.test(n);
+        // Strong service surface — NOT bare "badge" (that matched local getAllBadge / %AM*$badge*).
+        const STRONG_SERVICE_RE = /@ohos\.|@kit\.|ohos\.|notificationManager|notificationSubscribe|SubscribeManager|CommonEvent|telephony|bundleManager|wantAgent|osAccount|AppAccount|distributedAccount|accountManager|vibrator/i;
+        /** Domain kinship for sibling/writer Managers — stem match or service surface (not bare "ability"). */
+        const relatedToAnchor = (stem, sig) => {
+            const sl = stem.toLowerCase();
+            const blob = sig.toLowerCase();
+            if (sl.length >= 3 && blob.includes(sl))
+                return true;
+            if (STRONG_SERVICE_RE.test(sig))
+                return true;
+            if (/notification|numbadge|subscribe|commonevent/i.test(blob))
+                return true;
+            // Account* anchors may relate via account path without sharing the stem letters.
+            if (/^account$/i.test(stem) && /account|osaccount|appaccount/i.test(blob))
+                return true;
+            return false;
+        };
         const lines = ['**Data sources / upstream services**', ''];
-        let edgeCount = 0;
-        const addEdge = (bucket, node, via, rank, opts) => {
+        const sdkIds = new Set();
+        const strongIds = new Set();
+        const addEdge = (bucket, node, via, rank, kind, opts) => {
             if ((0, query_utils_1.isTestFile)(node.filePath))
                 return;
-            const sig = `${node.name} ${node.filePath} ${node.signature || ''}`;
-            // Same-file @ohos/@kit imports are always data-source candidates (BadgeManager
-            // → notificationManager), even when the import local name fails SERVICE_RE.
-            if (!opts?.importAlways && !SERVICE_RE.test(sig))
+            if (isAnonName(node.name))
                 return;
-            if (opts?.importAlways && !/@ohos\.|@kit\.|ohos\./i.test(sig))
+            const sig = `${node.name} ${node.filePath} ${node.signature || ''}`;
+            if (opts?.importAlways) {
+                if (!/@ohos\.|@kit\.|ohos\./i.test(sig))
+                    return;
+            }
+            else if (kind === 'strong') {
+                // caller / related / strong-callee paths already pre-filtered
+            }
+            else if (!STRONG_SERVICE_RE.test(sig)) {
                 return;
+            }
             const prev = bucket.get(node.id);
             if (!prev || rank < prev.rank) {
-                bucket.set(node.id, { name: node.name, file: rel(node.filePath), line: node.startLine, via, rank });
-                if (!prev)
-                    edgeCount++;
+                bucket.set(node.id, { name: node.name, file: rel(node.filePath), line: node.startLine, via, rank, kind });
+                if (kind === 'sdk') {
+                    sdkIds.add(node.id);
+                    strongIds.delete(node.id);
+                }
+                else {
+                    if (!sdkIds.has(node.id))
+                        strongIds.add(node.id);
+                }
             }
         };
         for (const name of anchors.slice(0, 3)) {
@@ -3844,13 +4388,14 @@ class ToolHandler {
                     if (e.kind !== 'contains')
                         continue;
                     const m = cg.getNode(e.target);
-                    if (m && (m.kind === 'method' || m.kind === 'function'))
+                    if (m && (m.kind === 'method' || m.kind === 'function') && !isAnonName(m.name))
                         methods.push(m);
                 }
                 if (methods.length === 0) {
                     for (const n of cg.getNodesByName(name)) {
-                        if (n.filePath === cls.filePath && (n.kind === 'method' || n.kind === 'function'))
+                        if (n.filePath === cls.filePath && (n.kind === 'method' || n.kind === 'function') && !isAnonName(n.name)) {
                             methods.push(n);
+                        }
                     }
                 }
                 // 1) Same-file @ohos / kit imports — the usual system-service surface.
@@ -3858,26 +4403,26 @@ class ToolHandler {
                     for (const r of cg.searchNodes('@ohos', { kinds: ['import'], limit: 40 })) {
                         if (r.node.filePath !== cls.filePath)
                             continue;
-                        addEdge(upstream, r.node, 'import', 0, { importAlways: true });
+                        addEdge(upstream, r.node, 'import', 0, 'sdk', { importAlways: true });
                     }
                     for (const r of cg.searchNodes('@kit', { kinds: ['import'], limit: 40 })) {
                         if (r.node.filePath !== cls.filePath)
                             continue;
-                        addEdge(upstream, r.node, 'import', 0, { importAlways: true });
+                        addEdge(upstream, r.node, 'import', 0, 'sdk', { importAlways: true });
                     }
                     for (const term of [
-                        'notification', 'badge', 'NumBadge', 'subscribe', 'bundle', 'ability',
-                        'account', 'osAccount', 'AppAccount', 'distributedAccount',
+                        'notification', 'subscribe', 'bundle', 'ability',
+                        'account', 'osAccount', 'AppAccount', 'distributedAccount', 'telephony',
                     ]) {
                         for (const r of cg.searchNodes(term, { kinds: ['import'], limit: 30 })) {
                             if (r.node.filePath !== cls.filePath)
                                 continue;
-                            addEdge(upstream, r.node, 'import', 1, { importAlways: true });
+                            addEdge(upstream, r.node, 'import', 1, 'sdk', { importAlways: true });
                         }
                     }
                 }
                 catch { /* */ }
-                // 2) Callees that look like services/APIs.
+                // 2) Callees that look like SDK / system service APIs (not local cache helpers).
                 for (const method of methods.slice(0, 25)) {
                     let callees = [];
                     try {
@@ -3887,9 +4432,56 @@ class ToolHandler {
                         continue;
                     }
                     for (const c of callees) {
-                        if (c?.node)
-                            addEdge(upstream, c.node, method.name, 2);
+                        if (!c?.node || isAnonName(c.node.name))
+                            continue;
+                        const sig = `${c.node.name} ${c.node.filePath} ${c.node.signature || ''}`;
+                        if (!STRONG_SERVICE_RE.test(sig))
+                            continue;
+                        addEdge(upstream, c.node, method.name, 2, 'strong');
+                    }
+                }
+                // 3) Writers: other Managers that call this Manager's update/set/on APIs.
+                const stem = name.replace(/(?:Manager|Service|Handler|Store|Provider|Controller)$/i, '');
+                for (const method of methods.slice(0, 20)) {
+                    if (!/^(?:update|set|on|subscribe|refresh|init|add|put)/i.test(method.name))
+                        continue;
+                    let callers = [];
+                    try {
+                        callers = cg.getCallers(method.id);
                     }
+                    catch {
+                        continue;
+                    }
+                    for (const c of callers.slice(0, 12)) {
+                        if (!c?.node || isAnonName(c.node.name) || (0, query_utils_1.isTestFile)(c.node.filePath))
+                            continue;
+                        if (c.node.filePath === cls.filePath)
+                            continue;
+                        const sig = `${c.node.name} ${c.node.filePath}`;
+                        if (!/(?:Manager|Service|Handler|Controller)$/i.test(c.node.name))
+                            continue;
+                        if (!relatedToAnchor(stem, sig))
+                            continue;
+                        addEdge(upstream, c.node, `caller→${method.name}`, 1, 'strong');
+                    }
+                }
+                // 4) Sibling *Manager types in the same domain (stem match).
+                if (stem.length >= 3) {
+                    try {
+                        for (const r of cg.searchNodes(stem, { kinds: ['class', 'struct', 'component'], limit: 24 })) {
+                            const n = r.node;
+                            if (n.name === name || (0, query_utils_1.isTestFile)(n.filePath) || isAnonName(n.name))
+                                continue;
+                            if (!/(?:Manager|Service|Handler|Controller)$/i.test(n.name))
+                                continue;
+                            if (!relatedToAnchor(stem, `${n.name} ${n.filePath}`))
+                                continue;
+                            // Prefer Subscribe / notification writers over weakly related Ability Managers.
+                            const rank = /Subscribe|notification/i.test(`${n.name} ${n.filePath}`) ? 2 : 3;
+                            addEdge(upstream, n, 'related Manager', rank, 'strong');
+                        }
+                    }
+                    catch { /* */ }
                 }
                 if (upstream.size === 0)
                     continue;
@@ -3901,42 +4493,589 @@ class ToolHandler {
                 if (ranked.length > 15)
                     lines.push(`- … and ${ranked.length - 15} more upstream symbol(s)`);
                 lines.push('');
-                lines.push('> Prefer `@ohos.*` / notification / bundle imports as the system-service answer; local helpers are secondary.');
-                lines.push('');
             }
         }
-        if (edgeCount === 0) {
-            lines.push('- No `@ohos`/`@kit` / service-like upstream edges indexed for the named Manager. ' +
-                '**ANSWER NOW** from the Manager definition file (prefer in-repo `AccountManager` / `*Manager.ets`, not SDK `.d.ts`).');
+        const sdkImportCount = sdkIds.size;
+        const strongCount = strongIds.size;
+        const edgeCount = sdkImportCount + strongCount;
+        const hasHardAnswer = sdkImportCount > 0 && !(0, query_utils_1.queryAsDataSourceDistinguishAsk)(query);
+        const hasLocator = edgeCount > 0;
+        if (!hasLocator) {
+            lines.push('- No `@ohos`/`@kit` imports or related service Managers indexed for the named type. ' +
+                'Treat the Manager definition as the **locator anchor**; ONE **narrow** Grep inside that file ' +
+                '(or its callers) for `@ohos` / service imports is OK — not a repo-wide storm.');
+            lines.push('');
+            lines.push('> **Partial locator** — do **not** treat local cache/RDB helpers as the system service. ' +
+                'Prefer `homegraph_callers` on `update*` / `set*` members, or a sibling `*Manager` / `*Subscribe*Manager`.');
             lines.push('');
-            return { section: lines.join('\n'), edgeCount: 0 };
+            return { section: lines.join('\n'), edgeCount: 0, sdkImportCount: 0, strongCount: 0 };
+        }
+        if (hasHardAnswer) {
+            lines.push('> Data-source survey — **ANSWER NOW** from system `@ohos`/`@kit` imports above first. ' +
+                'Do not Grep/search/callers the same Manager for the service name.');
+        }
+        else {
+            lines.push('> **Partial locator** — related writers / sibling Managers above are anchors, not a full answer. ' +
+                'ONE tighter explore with a named Type, or ONE narrow Grep for `@ohos` if still missing — ' +
+                'do **not** fan out `homegraph_node` / callers. Do **not** ANSWER NOW from local cache helpers.');
         }
-        lines.push('> Data-source survey — **ANSWER NOW** from upstream symbols above (system `@ohos`/`@kit` imports first). ' +
-            'Do not Grep/search/callers the same Manager for the service name.');
         lines.push('');
-        return { section: lines.join('\n'), edgeCount };
+        return { section: lines.join('\n'), edgeCount, sdkImportCount, strongCount };
     }
     /**
-     * Main-thread fast path for inventory surveys — skips the worker queue.
+     * Event-type inventory + which *Manager files import / handle them.
+     * Prefers enum members on the named `*Event` Type; softens ANSWER NOW when
+     * the graph only has noisy Type/file hits without a member list.
      */
-    tryFastPathResult(toolName, args) {
-        const query = args.query;
-        if (typeof query !== 'string')
-            return null;
-        const deferKind = (0, query_utils_1.queryShouldDeferToBuiltinTools)(query);
-        if (deferKind) {
-            return this.textResult((0, query_utils_1.homegraphDeferGuidance)(deferKind, query));
+    buildEventDispatchSection(cg, query, projectRoot) {
+        const types = (0, query_utils_1.extractTypeNamesFromQuery)(query).filter((t) => /Event$/i.test(t) || /Mgr$/i.test(t) || /Manager$/i.test(t));
+        const primaryEvents = types.filter((t) => /Event$/i.test(t));
+        if (types.length === 0) {
+            return { section: '', hitCount: 0, eventCount: 0, handlerCount: 0, memberCount: 0, complete: false };
         }
-        try {
-            const cg = this.getHomeGraph(args.projectPath);
-            const projectRoot = cg.getProjectRoot();
-            if (toolName === 'homegraph_explore') {
-                return this.tryFastInventoryExplore(cg, query, projectRoot)
-                    ?? this.tryLightMechanismExplore(cg, query, projectRoot)
-                    ?? this.tryCompactLocalSymbolExplore(cg, query, projectRoot);
+        const rel = (p) => p.replace(/\\/g, '/');
+        const eventNames = new Set();
+        const eventFiles = new Set();
+        const enumMembers = [];
+        const seenMember = new Set();
+        /** Exported `*Event` classes from a named Event module file (not enum members). */
+        const eventClasses = [];
+        const seenEventClass = new Set();
+        const considerEventFile = (fp, preferredName) => {
+            eventFiles.add(fp);
+            if (/Event$/i.test(preferredName))
+                eventNames.add(preferredName);
+            try {
+                for (const sib of cg.getNodesInFile(fp)) {
+                    if ((0, query_utils_1.isTestFile)(sib.filePath))
+                        continue;
+                    if (sib.kind === 'enum_member') {
+                        const key = `${sib.name}:${rel(sib.filePath)}`;
+                        if (seenMember.has(key))
+                            continue;
+                        seenMember.add(key);
+                        enumMembers.push({ name: sib.name, file: rel(sib.filePath), line: sib.startLine || 1 });
+                    }
+                    // Barrel / module files often export many `*Event` classes (not enums).
+                    if ((sib.kind === 'enum' || sib.kind === 'class' || sib.kind === 'type_alias' || sib.kind === 'interface')
+                        && /Event$/i.test(sib.name)) {
+                        eventNames.add(sib.name);
+                        if (sib.kind === 'class' || sib.kind === 'enum' || sib.kind === 'type_alias') {
+                            const ck = `${sib.name}:${rel(sib.filePath)}`;
+                            if (!seenEventClass.has(ck)) {
+                                seenEventClass.add(ck);
+                                eventClasses.push({
+                                    name: sib.name,
+                                    file: rel(sib.filePath),
+                                    line: sib.startLine || 1,
+                                });
+                            }
+                        }
+                    }
+                }
             }
-            if (toolName === 'homegraph_search') {
-                return this.tryFastInventoryExplore(cg, query, projectRoot)
+            catch { /* */ }
+        };
+        for (const name of (primaryEvents.length > 0 ? primaryEvents : types).slice(0, 4)) {
+            let nodes = [];
+            try {
+                nodes = cg.getNodesByName(name);
+            }
+            catch {
+                nodes = [];
+            }
+            // File / export-only Event Types: getNodesByName can miss while search finds the file.
+            if (nodes.length === 0 && /Event$/i.test(name)) {
+                try {
+                    for (const r of cg.searchNodes(name, { limit: 24 })) {
+                        if ((0, query_utils_1.isTestFile)(r.node.filePath))
+                            continue;
+                        const base = r.node.filePath.replace(/\\/g, '/').split('/').pop() || '';
+                        const stem = base.replace(/\.(ets|ts|d\.ts)$/i, '');
+                        if (r.node.name === name || stem === name || r.node.kind === 'file') {
+                            nodes.push(r.node);
+                        }
+                    }
+                }
+                catch { /* */ }
+            }
+            for (const n of nodes) {
+                if ((0, query_utils_1.isTestFile)(n.filePath))
+                    continue;
+                if (/Event$/i.test(n.name)
+                    || n.kind === 'enum'
+                    || n.kind === 'class'
+                    || n.kind === 'type_alias'
+                    || n.kind === 'interface'
+                    || n.kind === 'file'
+                    || (n.kind === 'export' && /Event$/i.test(name))) {
+                    const label = /Event$/i.test(n.name) ? n.name : name;
+                    if (/Event$/i.test(label))
+                        eventNames.add(label);
+                    considerEventFile(n.filePath, label);
+                }
+            }
+        }
+        if (eventNames.size === 0 && enumMembers.length === 0) {
+            return {
+                section: [
+                    '**Event types → Manager / handler sites**',
+                    '',
+                    '> **Partial locator** — no event Type/enum exports indexed for the named anchors. '
+                        + '`homegraph_node` / ONE explore on the Event Type file, or ONE Grep for enum members / '
+                        + '`case` branches — not a repo-wide storm. Do **not** ANSWER NOW.',
+                    '',
+                ].join('\n'),
+                hitCount: 0,
+                eventCount: 0,
+                handlerCount: 0,
+                memberCount: 0,
+                complete: false,
+            };
+        }
+        const lines = [
+            '**Event types → Manager / handler sites**',
+            '',
+        ];
+        const rankedClasses = [...eventClasses].sort((a, b) => a.name.localeCompare(b.name));
+        if (enumMembers.length > 0) {
+            lines.push('### Event enum members (indexed)');
+            for (const m of enumMembers.slice(0, 40)) {
+                lines.push(`- \`${m.name}\` — \`${m.file}:${m.line}\``);
+            }
+            if (enumMembers.length > 40)
+                lines.push(`- … and ${enumMembers.length - 40} more`);
+            lines.push('');
+        }
+        // Named `*Event` module files often export many Event classes (not enums).
+        // Listing them is the answer to "有哪些事件类型" — don't force Grep for members.
+        if (eventClasses.length > 0) {
+            lines.push('### Event type classes (exported from Event module)');
+            for (const c of rankedClasses.slice(0, 40)) {
+                lines.push(`- \`${c.name}\` — \`${c.file}:${c.line}\``);
+            }
+            if (rankedClasses.length > 40) {
+                lines.push(`- … and ${rankedClasses.length - 40} more Event class(es)`);
+            }
+            lines.push('');
+        }
+        lines.push('### Event Type anchors');
+        // Prefer concrete Event classes over the barrel file stem when both exist.
+        const anchorEvents = (eventClasses.length > 0
+            ? eventClasses.map((c) => c.name)
+            : [...eventNames]).filter((n, i, arr) => arr.indexOf(n) === i)
+            .sort((a, b) => a.localeCompare(b));
+        const sortedEvents = anchorEvents;
+        for (const ev of sortedEvents.slice(0, 12)) {
+            let loc = '';
+            try {
+                const n = cg.getNodesByName(ev).find((x) => !(0, query_utils_1.isTestFile)(x.filePath));
+                if (n)
+                    loc = ` — \`${rel(n.filePath)}:${n.startLine}\``;
+            }
+            catch { /* */ }
+            if (!loc) {
+                const fromClass = eventClasses.find((c) => c.name === ev);
+                if (fromClass)
+                    loc = ` — \`${fromClass.file}:${fromClass.line}\``;
+            }
+            if (!loc) {
+                for (const fp of eventFiles) {
+                    const base = rel(fp).split('/').pop() || '';
+                    const stem = base.replace(/\.(ets|ts|d\.ts)$/i, '');
+                    if (stem === ev || base.includes(ev)) {
+                        loc = ` — \`${rel(fp)}\``;
+                        break;
+                    }
+                }
+            }
+            lines.push(`- \`${ev}\`${loc}`);
+        }
+        lines.push('');
+        // Search handlers by primary Event names (+ a few members), not every noisy sibling.
+        const searchKeys = [
+            ...sortedEvents.slice(0, 12),
+            ...enumMembers.slice(0, 12).map((m) => m.name),
+        ];
+        const hits = new Map();
+        for (const key of searchKeys) {
+            let results = [];
+            try {
+                results = cg.searchNodes(key, { limit: 36 });
+            }
+            catch {
+                continue;
+            }
+            for (const r of results) {
+                const fp = rel(r.node.filePath);
+                if ((0, query_utils_1.isTestFile)(fp))
+                    continue;
+                if (eventFiles.has(r.node.filePath) && (r.node.name === key || r.node.kind === 'enum_member'))
+                    continue;
+                const isMgr = /Manager|Handler|Dispatcher|Controller/i.test(fp)
+                    || /Manager|Handler|Dispatcher|Controller/i.test(r.node.name);
+                if (!isMgr && r.node.kind !== 'import')
+                    continue;
+                const abs = (0, path_1.isAbsolute)(r.node.filePath)
+                    ? r.node.filePath
+                    : (0, path_1.join)(projectRoot, r.node.filePath);
+                let snippet = (r.node.signature || r.node.name).slice(0, 100);
+                let lineHasKey = false;
+                try {
+                    const content = (0, fs_1.readFileSync)(abs, 'utf-8');
+                    const fileLines = content.split('\n');
+                    const li = Math.max(0, (r.node.startLine || 1) - 1);
+                    const line = fileLines[li] ?? '';
+                    lineHasKey = line.includes(key);
+                    if (lineHasKey || /import/i.test(line))
+                        snippet = line.trim().slice(0, 120);
+                }
+                catch { /* */ }
+                // Drop weak FTS hits that neither import nor mention the key on the line.
+                if (!lineHasKey && r.node.kind !== 'import' && r.node.name !== key)
+                    continue;
+                const prev = hits.get(fp) ?? {
+                    file: fp,
+                    line: r.node.startLine || 1,
+                    snippet,
+                    score: 0,
+                    events: new Set(),
+                };
+                prev.events.add(key);
+                prev.score += isMgr ? 3 : 1;
+                if (r.node.kind === 'import')
+                    prev.score += 2;
+                if (lineHasKey)
+                    prev.score += 2;
+                if (!prev.snippet && snippet)
+                    prev.snippet = snippet;
+                hits.set(fp, prev);
+            }
+        }
+        const ranked = [...hits.values()].sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
+        const consumerHits = [];
+        const consumerSeen = new Set();
+        const eventNamesForConsumers = rankedClasses.length > 0
+            ? rankedClasses.map((c) => c.name)
+            : sortedEvents;
+        const addConsumer = (file, line, snippet, event, score) => {
+            const key = `${file}:${line}:${event}`;
+            if (consumerSeen.has(key))
+                return;
+            consumerSeen.add(key);
+            consumerHits.push({ file, line, snippet: snippet.slice(0, 120), event, score });
+        };
+        for (const ev of eventNamesForConsumers.slice(0, 24)) {
+            let results = [];
+            try {
+                results = cg.searchNodes(ev, { limit: 36 });
+            }
+            catch {
+                continue;
+            }
+            const esc = ev.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const onRe = new RegExp(`(?:InnerEventUtil|evtBus|eventMgr|EventMgr|focusMode\\w*EventMgr)\\.on\\s*\\(\\s*${esc}|\\.on\\s*\\(\\s*${esc}`);
+            const seenFiles = new Set();
+            for (const r of results) {
+                const fp = rel(r.node.filePath);
+                if ((0, query_utils_1.isTestFile)(fp) || eventFiles.has(r.node.filePath))
+                    continue;
+                if (seenFiles.has(fp))
+                    continue;
+                seenFiles.add(fp);
+                const abs = (0, path_1.isAbsolute)(r.node.filePath)
+                    ? r.node.filePath
+                    : (0, path_1.join)(projectRoot, r.node.filePath);
+                let content = '';
+                try {
+                    content = (0, fs_1.readFileSync)(abs, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                const fileLines = content.split('\n');
+                for (let i = 0; i < fileLines.length; i++) {
+                    const line = fileLines[i] ?? '';
+                    if (!onRe.test(line) && !line.includes(`produceOn(${ev}`) && !line.includes(`produceOn(${ev},`)) {
+                        continue;
+                    }
+                    let score = 4;
+                    if (/Controller|Manager|Handler|Vm$/i.test(fp))
+                        score += 6;
+                    if (/\.on\s*\(/.test(line))
+                        score += 4;
+                    if (/produceOn/.test(line))
+                        score += 3;
+                    addConsumer(fp, i + 1, line.trim(), ev, score);
+                }
+            }
+        }
+        // DataShareManager produceOn registrations (producer side of dispatch).
+        let mgrNodes = [];
+        try {
+            mgrNodes = cg.getNodesByName('DataShareManager').filter((n) => !(0, query_utils_1.isTestFile)(n.filePath));
+        }
+        catch {
+            mgrNodes = [];
+        }
+        for (const n of mgrNodes.slice(0, 2)) {
+            const fp = rel(n.filePath);
+            const abs = (0, path_1.isAbsolute)(n.filePath) ? n.filePath : (0, path_1.join)(projectRoot, n.filePath);
+            try {
+                const fileLines = (0, fs_1.readFileSync)(abs, 'utf-8').split('\n');
+                for (let i = 0; i < fileLines.length; i++) {
+                    const line = fileLines[i] ?? '';
+                    if (!/produceOn\s*\(/.test(line))
+                        continue;
+                    const evM = line.match(/produceOn\s*\(\s*([A-Za-z_][\w]*Event)/);
+                    const evName = evM?.[1] ?? 'produceOn';
+                    addConsumer(fp, i + 1, line.trim(), evName, 5);
+                    if (consumerHits.length >= 10)
+                        break;
+                }
+            }
+            catch { /* optional */ }
+        }
+        consumerHits.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
+        if (consumerHits.length > 0) {
+            lines.push('### Event consumer registrations (`.on` / `produceOn`)');
+            for (const h of consumerHits.slice(0, 16)) {
+                lines.push(`- \`${h.file}:${h.line}\` ← \`${h.event}\`  \`${h.snippet}\``);
+            }
+            if (consumerHits.length > 16) {
+                lines.push(`- … and ${consumerHits.length - 16} more consumer site(s)`);
+            }
+            lines.push('');
+        }
+        lines.push('### Manager / handler files referencing these events');
+        const memberCount = enumMembers.length;
+        const eventClassCount = eventClasses.length;
+        const dispatchAsk = /分发|分发给|DataShareMgr|dispatch|routed?\s+to/i.test(query);
+        // Complete when: enum members + handlers, OR Event classes + consumer wiring
+        // for dispatch asks, OR a tight Event Type set.
+        const complete = ranked.length > 0
+            && ((memberCount > 0 && memberCount <= 48 && ranked.length >= 1)
+                || (eventClassCount >= 3 && eventClassCount <= 64
+                    && (dispatchAsk ? consumerHits.length >= 2 : ranked.length >= 1))
+                || (sortedEvents.length > 0 && sortedEvents.length <= 4 && ranked.length >= 1 && ranked[0].score >= 5)
+                || (dispatchAsk && consumerHits.length >= 3));
+        if (ranked.length === 0) {
+            lines.push('- No Manager import/use sites indexed for these event types.');
+            lines.push('');
+            lines.push('> **Partial locator** — event anchors above only. '
+                + '`homegraph_node` the Event file or ONE Grep for handler/`case` branches — do **not** ANSWER NOW as a full dispatch map.');
+        }
+        else {
+            for (const h of ranked.slice(0, 24)) {
+                const evs = [...h.events].slice(0, 4).join(', ');
+                lines.push(h.snippet
+                    ? `- \`${h.file}:${h.line}\` ← \`${evs}\`  \`${h.snippet}\``
+                    : `- \`${h.file}:${h.line}\` ← \`${evs}\``);
+            }
+            if (ranked.length > 24)
+                lines.push(`- … and ${ranked.length - 24} more handler file(s)`);
+            lines.push('');
+            if (complete) {
+                lines.push(eventClassCount > 0
+                    ? '> Event→Manager inventory — **ANSWER NOW** from Event type classes + consumer `.on` / handler files above; '
+                        + 'ONE narrow Grep only if a specific Manager→event branch is still missing.'
+                    : '> Event→Manager inventory — **ANSWER NOW** from enum members + handler files above; '
+                        + 'ONE narrow Grep only if a specific `case` branch is still missing.');
+            }
+            else if (eventClassCount >= 3 && dispatchAsk && consumerHits.length === 0) {
+                lines.push('> **Partial locator** — Event type list above is complete, but consumer `.on` / dispatch wiring '
+                    + 'was not indexed. ONE Grep for `.on(EventName` or `produceOn` in `*Manager*` files — '
+                    + 'do **not** repo-storm; do **not** ANSWER NOW as a full dispatch map.');
+            }
+            else {
+                lines.push('> **Partial locator** — handler files are anchors, but enum-member coverage may be incomplete. '
+                    + '`homegraph_node` the Event Type / ONE Grep for members or `case` — do **not** repo-storm; do **not** ANSWER NOW as a full map.');
+            }
+        }
+        lines.push('');
+        return {
+            section: lines.join('\n'),
+            hitCount: ranked.length + memberCount + eventClassCount,
+            eventCount: Math.max(sortedEvents.length, eventClassCount, memberCount > 0 ? 1 : 0),
+            handlerCount: ranked.length,
+            memberCount: memberCount + eventClassCount,
+            complete,
+        };
+    }
+    /**
+     * ≥3 named Types + dependency ask — file locations + cross-imports only.
+     * Avoids fat multi-body compact that hits the soft deadline (D60).
+     */
+    buildMultiTypeDependencySection(cg, query) {
+        const types = (0, query_utils_1.extractTypeNamesFromQuery)(query).filter((t) => t.length >= 8
+            || /(?:Manager|Installer|Parser|Service|Controller|Handler|Provider|Store)$/i.test(t));
+        if (types.length < 3)
+            return { section: '', hitCount: 0 };
+        const rel = (p) => p.replace(/\\/g, '/');
+        const locs = [];
+        const fileByType = new Map();
+        for (const name of types.slice(0, 8)) {
+            let nodes = [];
+            try {
+                nodes = cg.getNodesByName(name).filter((n) => !(0, query_utils_1.isTestFile)(n.filePath)
+                    && !(0, arkts_1.isOhosApiFilePath)(n.filePath)
+                    && !/\.d\.ts$/i.test(n.filePath)
+                    && (n.kind === 'class' || n.kind === 'struct' || n.kind === 'interface' || n.kind === 'component'));
+            }
+            catch {
+                continue;
+            }
+            if (nodes.length === 0) {
+                try {
+                    for (const r of cg.searchNodes(name, { limit: 12 })) {
+                        if ((0, query_utils_1.isTestFile)(r.node.filePath) || (0, arkts_1.isOhosApiFilePath)(r.node.filePath))
+                            continue;
+                        if (r.node.name === name || r.node.kind === 'class') {
+                            nodes.push(r.node);
+                            break;
+                        }
+                    }
+                }
+                catch { /* */ }
+            }
+            const n = nodes[0];
+            if (!n)
+                continue;
+            locs.push({ name, file: rel(n.filePath), line: n.startLine || 1 });
+            fileByType.set(name, rel(n.filePath));
+        }
+        if (locs.length === 0)
+            return { section: '', hitCount: 0 };
+        const lines = [
+            '**Named-Type dependency inventory** (locations + cross-file imports — no full bodies)',
+            '',
+            '### Types (indexed)',
+        ];
+        for (const l of locs) {
+            lines.push(`- \`${l.name}\` — \`${l.file}:${l.line}\``);
+        }
+        lines.push('');
+        // Cross edges: does Type A's file import/reference Type B?
+        const edges = [];
+        for (const a of locs) {
+            let fileNodes = [];
+            try {
+                fileNodes = cg.getNodesInFile(a.file);
+            }
+            catch {
+                continue;
+            }
+            const blob = fileNodes
+                .filter((n) => n.kind === 'import' || n.kind === 'export')
+                .map((n) => `${n.name} ${n.signature || ''}`)
+                .join('\n');
+            for (const b of locs) {
+                if (a.name === b.name)
+                    continue;
+                if (blob.includes(b.name) || fileNodes.some((n) => n.name === b.name && n.kind === 'import')) {
+                    edges.push(`- \`${a.name}\` → \`${b.name}\` (import/ref in \`${a.file}\`)`);
+                }
+            }
+            // Also check callers between types (light).
+            try {
+                const seed = cg.getNodesByName(a.name).find((n) => rel(n.filePath) === a.file);
+                if (!seed)
+                    continue;
+                for (const { node: c } of cg.getCallers(seed.id).slice(0, 20)) {
+                    if ((0, query_utils_1.isTestFile)(c.filePath))
+                        continue;
+                    for (const b of locs) {
+                        if (b.name === a.name)
+                            continue;
+                        if (c.name === b.name || rel(c.filePath) === fileByType.get(b.name)) {
+                            edges.push(`- \`${b.name}\` → calls/uses \`${a.name}\` (\`${rel(c.filePath)}:${c.startLine}\`)`);
+                        }
+                    }
+                }
+            }
+            catch { /* */ }
+        }
+        lines.push('### Cross links (imports / callers)');
+        if (edges.length === 0) {
+            lines.push('- No import/caller edges indexed between these Types yet.');
+        }
+        else {
+            const uniq = [...new Set(edges)].slice(0, 40);
+            lines.push(...uniq);
+        }
+        lines.push('');
+        // Text-scan `extends Base` when graph edges are missing — shared bases are
+        // the usual answer to "这几个 Installer/Parser 的依赖关系".
+        const extendsHits = [];
+        const baseNames = new Set();
+        let projectRoot = '';
+        try {
+            projectRoot = cg.getProjectRoot();
+        }
+        catch { /* */ }
+        for (const a of locs) {
+            let content = '';
+            try {
+                const full = (0, path_1.isAbsolute)(a.file) ? a.file : (projectRoot ? (0, path_1.join)(projectRoot, a.file) : '');
+                if (full && (0, fs_1.existsSync)(full))
+                    content = (0, fs_1.readFileSync)(full, 'utf-8');
+            }
+            catch { /* */ }
+            if (!content)
+                continue;
+            const m = content.match(new RegExp(`(?:export\\s+)?(?:abstract\\s+)?class\\s+${a.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s+extends\\s+([A-Za-z_][A-Za-z0-9_]*)`));
+            if (!m?.[1])
+                continue;
+            const base = m[1];
+            baseNames.add(base);
+            extendsHits.push(`- \`${a.name}\` extends \`${base}\``);
+        }
+        if (extendsHits.length > 0) {
+            lines.push('### Inheritance (source `extends`)');
+            lines.push(...[...new Set(extendsHits)].slice(0, 20));
+            if (baseNames.size > 0) {
+                lines.push('');
+                lines.push(`Shared / parent Type(s): ${[...baseNames].slice(0, 8).map((b) => `\`${b}\``).join(', ')}.`);
+            }
+            lines.push('');
+        }
+        const hasGraph = edges.length > 0;
+        const hasExtends = extendsHits.length > 0;
+        if (!hasGraph && !hasExtends) {
+            lines.push('> **Partial locator** — Type files above are anchors. '
+                + '`homegraph_node` / `homegraph_callees` one Type at a time; do **not** ANSWER NOW as a full graph.');
+        }
+        else {
+            lines.push('> Multi-Type dependency inventory — **ANSWER NOW** from locations'
+                + (hasExtends ? ' + `extends` bases' : '')
+                + (hasGraph ? ' + import/caller edges' : '')
+                + ' above; only `homegraph_node` one Type if a body detail is still missing.');
+        }
+        lines.push('');
+        return { section: lines.join('\n'), hitCount: locs.length + edges.length + extendsHits.length };
+    }
+    /**
+     * Main-thread fast path for inventory surveys — skips the worker queue.
+     */
+    tryFastPathResult(toolName, args) {
+        const query = args.query;
+        if (typeof query !== 'string')
+            return null;
+        const deferKind = (0, query_utils_1.queryShouldDeferToBuiltinTools)(query);
+        if (deferKind) {
+            return this.textResult((0, query_utils_1.homegraphDeferGuidance)(deferKind, query));
+        }
+        try {
+            const cg = this.getHomeGraph(args.projectPath);
+            const projectRoot = cg.getProjectRoot();
+            if (toolName === 'homegraph_explore') {
+                return this.trySpecializedExploreRoute(cg, query, projectRoot)
+                    ?? this.tryFastInventoryExplore(cg, query, projectRoot)
+                    ?? this.tryLightMechanismExplore(cg, query, projectRoot)
+                    ?? this.tryCompactLocalSymbolExplore(cg, query, projectRoot);
+            }
+            if (toolName === 'homegraph_search') {
+                return this.tryFastInventoryExplore(cg, query, projectRoot)
                     ?? this.tryLightMechanismExplore(cg, query, projectRoot)
                     ?? this.tryCompactLocalSymbolExplore(cg, query, projectRoot);
             }
@@ -3946,12 +5085,258 @@ class ToolHandler {
         }
         return null;
     }
+    /** Conservative compatibility router: ambiguous mechanism queries stay broad. */
+    specializedExploreRouteForQuery(query) {
+        if ((0, query_utils_1.queryAsModuleDependencySurvey)(query))
+            return 'modules';
+        if ((0, query_utils_1.queryAsModuleExportSurvey)(query))
+            return 'native';
+        if ((0, query_utils_1.queryAsReturnValueConsumerSurvey)(query))
+            return null;
+        if ((0, query_utils_1.shouldBuildApiUsageSurvey)(query))
+            return 'usages';
+        if (queryAsBareSymbolInventory(query))
+            return 'usages';
+        if (!(0, query_utils_1.shouldBuildMemberSurvey)(query))
+            return null;
+        return /哪里(?:用|使用|调用)|哪些.{0,24}(?:用|使用|调用|依赖)|使用位置|引用位置|调用位置|\busages?\b|\bwhere\b.{0,36}\bused\b|\bwhich\b.{0,36}\b(?:files?|functions?|methods?)\b.{0,24}\b(?:use|call|depend)/i.test(query)
+            ? 'usages'
+            : null;
+    }
+    /** Run exactly one bounded survey family and expose the selected route. */
+    runSpecializedExploreRoute(route, cg, query, projectRoot) {
+        let section = '';
+        let status = 'no_indexed_evidence';
+        let coverage = '';
+        if (route === 'modules') {
+            const manifestResult = this.buildFocusedModuleManifestSection(projectRoot, query);
+            const graphResult = manifestResult.manifestCount === 0
+                ? this.buildModuleDependencySurveySection(cg, query)
+                : { section: '', hitCount: 0 };
+            section = manifestResult.section || graphResult.section;
+            status = section ? 'complete' : 'no_indexed_evidence';
+            coverage = manifestResult.manifestCount > 0
+                ? 'named module manifests plus bounded linter evidence only; no full-repo cycle walk or unrelated surveys were built'
+                : 'named-module dependency/cycle graph only; no source bodies or unrelated surveys were built';
+        }
+        else if (route === 'native') {
+            const result = this.buildModuleExportSurveySection(cg, query, projectRoot);
+            section = result.section;
+            status = result.hitCount > 0 ? 'complete' : 'no_indexed_evidence';
+            coverage = 'named path/Type NAPI export registrations only; no domain file dump was built';
+        }
+        else {
+            const apiUsage = (0, query_utils_1.shouldBuildApiUsageSurvey)(query)
+                ? this.buildApiUsageSection(cg, query, projectRoot)
+                : { section: '', fileCount: 0 };
+            const memberUsage = (0, query_utils_1.shouldBuildMemberSurvey)(query)
+                && !((0, query_utils_1.queryAsFieldUsageSurvey)(query) && apiUsage.fileCount > 0)
+                ? this.buildMemberSurveySection(cg, query, projectRoot)
+                : '';
+            let scanned = (0, query_utils_1.shouldBuildApiUsageSurvey)(query) || (0, query_utils_1.shouldBuildMemberSurvey)(query);
+            section = [apiUsage.section, memberUsage].filter(Boolean).join('\n');
+            if (!section) {
+                const bare = this.buildBareSymbolUsageSection(cg, query, projectRoot);
+                scanned = scanned || bare.scanned;
+                section = bare.section;
+            }
+            status = section ? 'complete' : (scanned ? 'no_indexed_evidence' : 'not_surveyed');
+            coverage = 'named API/member/constant/field usage sites only; no general call-flow or source dump was built';
+        }
+        const body = section
+            || (status === 'not_surveyed'
+                ? '- No survey ran: this query carries no symbol name to scan. Re-run naming the symbol(s), or use `homegraph_explore`.'
+                : '- No matching evidence was found in the current index for this focused survey.');
+        return this.textResult(this.truncateOutput([
+            `**HomeGraph specialized route: ${route}**`,
+            `Status: ${status}`,
+            `Coverage: ${coverage}.`,
+            '',
+            body,
+        ].join('\n')));
+    }
+    /** Usage sites for a bare symbol bag, including non-call textual references. */
+    buildBareSymbolUsageSection(cg, query, projectRoot) {
+        const symbols = extractBareUsageSymbols(query);
+        if (symbols.length === 0)
+            return { section: '', scanned: false };
+        const MAX_SYMBOLS = 4;
+        const MAX_FILES_SCANNED = 80;
+        const MAX_FILES_REPORTED = 14;
+        const MAX_LINES_PER_FILE = 3;
+        const rel = (p) => p.replace(/\\/g, '/');
+        const byFile = new Map();
+        const seenFiles = new Set();
+        let matchedFiles = 0;
+        const matchers = symbols.slice(0, MAX_SYMBOLS).map((sym) => ({
+            sym,
+            re: new RegExp(`\\b${sym.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`),
+        }));
+        const scanFile = (fp) => {
+            const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, fp);
+            if (!abs)
+                return { rows: [], bytes: 0 };
+            let content;
+            try {
+                content = (0, fs_1.readFileSync)(abs, 'utf-8');
+            }
+            catch {
+                return { rows: [], bytes: 0 };
+            }
+            const bytes = content.length;
+            const hit = matchers.filter((m) => m.re.test(content));
+            if (hit.length === 0)
+                return { rows: [], bytes };
+            const fileLines = content.split('\n');
+            const rows = [];
+            for (let i = 0; i < fileLines.length && rows.length < MAX_LINES_PER_FILE; i++) {
+                const text = (fileLines[i] ?? '').trim();
+                if (!text)
+                    continue;
+                const m = hit.find((x) => x.re.test(text));
+                if (m)
+                    rows.push({ line: i + 1, text, symbol: m.sym });
+            }
+            return { rows, bytes };
+        };
+        const record = (fp, rows) => {
+            if (rows.length === 0)
+                return;
+            matchedFiles++;
+            if (byFile.size < MAX_FILES_REPORTED)
+                byFile.set(fp, rows);
+        };
+        for (const { sym } of matchers) {
+            let nodes = [];
+            try {
+                nodes = cg.searchNodes(sym, { limit: 60 });
+            }
+            catch {
+                continue;
+            }
+            for (const r of nodes) {
+                if (seenFiles.size >= MAX_FILES_SCANNED)
+                    break;
+                const fp = rel(r.node.filePath);
+                if ((0, query_utils_1.isTestFile)(fp) || seenFiles.has(fp))
+                    continue;
+                seenFiles.add(fp);
+                record(fp, scanFile(fp).rows);
+            }
+        }
+        const SWEEP_DEADLINE_MS = 3000;
+        const SWEEP_MAX_FILES = 20000;
+        const SWEEP_MAX_BYTES = 256 * 1024 * 1024;
+        let sweepRan = false;
+        let sweepComplete = false;
+        if (process.env.HOMEGRAPH_EXPLORE_USAGE_SWEEP !== '0') {
+            let corpus = [];
+            try {
+                corpus = cg.getFiles();
+            }
+            catch {
+                corpus = [];
+            }
+            if (corpus.length > 0) {
+                sweepRan = true;
+                sweepComplete = true;
+                const started = Date.now();
+                let swept = 0;
+                let bytesRead = 0;
+                for (const f of corpus) {
+                    if (swept >= SWEEP_MAX_FILES || bytesRead >= SWEEP_MAX_BYTES
+                        || (swept % 64 === 0 && Date.now() - started > SWEEP_DEADLINE_MS)) {
+                        sweepComplete = false;
+                        break;
+                    }
+                    const fp = rel(String(f?.path ?? ''));
+                    if (!fp || (0, query_utils_1.isTestFile)(fp) || seenFiles.has(fp))
+                        continue;
+                    seenFiles.add(fp);
+                    swept++;
+                    const scan = scanFile(fp);
+                    bytesRead += scan.bytes;
+                    record(fp, scan.rows);
+                }
+            }
+        }
+        if (byFile.size === 0)
+            return { section: '', scanned: true };
+        const truncated = matchedFiles > byFile.size;
+        const lines = [
+            `**Symbol usage sites** — \`${symbols.slice(0, MAX_SYMBOLS).join('`, `')}\``, '',
+            sweepRan && sweepComplete
+                ? '> Full in-repo text sweep of every indexed source file: includes non-call references with no `calls` edge.'
+                : '> Scanned in-repo: includes non-call references with no `calls` edge.',
+            '',
+        ];
+        for (const [file, rows] of byFile) {
+            lines.push(`- \`${file}\``);
+            for (const row of rows)
+                lines.push(`    - ${row.line}: \`${row.text.slice(0, 120)}\``);
+        }
+        lines.push('');
+        if (truncated) {
+            lines.push(`> Showing ${byFile.size} of ${matchedFiles} matching file(s) — narrow the symbol to see the rest.`);
+        }
+        else if (sweepRan && sweepComplete) {
+            lines.push(`> ${byFile.size} file(s) — every indexed source file was swept, so this is the complete in-repo list. **ANSWER NOW** from it: do not re-grep these names.`);
+        }
+        else {
+            lines.push(`> ${byFile.size} indexed use site file(s); the text sweep did not complete, so files that merely reference these names may be missing.`);
+        }
+        return { section: lines.join('\n'), scanned: true };
+    }
+    trySpecializedExploreRoute(cg, query, projectRoot) {
+        const route = this.specializedExploreRouteForQuery(query);
+        return route ? this.runSpecializedExploreRoute(route, cg, query, projectRoot) : null;
+    }
+    async handleSpecializedUsages(args) {
+        const query = this.validateString(args.query, 'query');
+        if (typeof query !== 'string')
+            return query;
+        const cg = this.getHomeGraph(args.projectPath);
+        return this.runSpecializedExploreRoute('usages', cg, query, cg.getProjectRoot());
+    }
+    async handleSpecializedModules(args) {
+        const query = this.validateString(args.query, 'query');
+        if (typeof query !== 'string')
+            return query;
+        const cg = this.getHomeGraph(args.projectPath);
+        return this.runSpecializedExploreRoute('modules', cg, query, cg.getProjectRoot());
+    }
+    async handleSpecializedNative(args) {
+        const query = this.validateString(args.query, 'query');
+        if (typeof query !== 'string')
+            return query;
+        const cg = this.getHomeGraph(args.projectPath);
+        return this.runSpecializedExploreRoute('native', cg, query, cg.getProjectRoot());
+    }
     /**
      * Fast inventory-only explore — skips findRelevantContext for survey/caller/dependency queries.
      */
     tryFastInventoryExplore(cg, query, projectRoot) {
         if (!(0, query_utils_1.shouldTryFastInventoryExplore)(query))
             return null;
+        // Multi-Type dependency asks: inventory-only early exit (avoids fat compact / 25s busy).
+        if ((0, query_utils_1.queryAsMultiTypeDependencySurvey)(query)) {
+            const multi = this.buildMultiTypeDependencySection(cg, query);
+            if (multi.section) {
+                const soft = /Partial locator/i.test(multi.section);
+                return this.textResult([
+                    `**Exploration: ${query}**`,
+                    '',
+                    soft
+                        ? `Named-Type dependency inventory — **${multi.hitCount}** locator hit(s). `
+                            + '**Partial locator** — locations above; ONE tighter explore with a named Type, '
+                            + 'or ONE narrow Grep — do **not** fan out `homegraph_node` / callees.'
+                        : `Named-Type dependency inventory — **${multi.hitCount}** locator hit(s). `
+                            + '**ANSWER NOW** from locations + cross links; one `homegraph_node` only if a body detail is still missing.',
+                    '',
+                    multi.section,
+                ].join('\n'));
+            }
+        }
         const lines = [`**Exploration: ${query}**`, '', ''];
         const summaryLineIdx = 2;
         const inheritanceOnly = (0, query_utils_1.shouldBuildInheritanceSurvey)(query);
@@ -4007,6 +5392,9 @@ class ToolHandler {
             || (0, query_utils_1.queryIsTypeNameFocus)(query)
             || (0, query_utils_1.queryAsInheritanceSurvey)(query)
             || (0, query_utils_1.queryAsDataSourceSurvey)(query)
+            || (0, query_utils_1.queryAsEventDispatchSurvey)(query)
+            || (0, query_utils_1.queryAsOutOfRepoSdkCatalog)(query)
+            || (0, query_utils_1.queryAsKitModuleCapabilitySurvey)(query)
             || (0, query_utils_1.shouldBuildApiUsageSurvey)(query)
             || (0, query_utils_1.queryAsInRepoSystemCapabilityHowto)(query)
             || (0, query_utils_1.queryAsReturnValueConsumerSurvey)(query)
@@ -4065,7 +5453,7 @@ class ToolHandler {
             lines.push(moduleDepResult.section);
         const moduleExportResult = (0, query_utils_1.queryAsModuleExportSurvey)(query)
             ? this.buildModuleExportSurveySection(cg, query, projectRoot)
-            : { section: '', hitCount: 0 };
+            : { section: '', hitCount: 0, shellOnly: false };
         if (moduleExportResult.section)
             lines.push(moduleExportResult.section);
         const dtsWrapResult = (0, query_utils_1.queryAsDtsWrapSurvey)(query)
@@ -4080,14 +5468,24 @@ class ToolHandler {
             lines.push(controlSyncResult.section);
         const dataSourceResult = (0, query_utils_1.queryAsDataSourceSurvey)(query)
             ? this.buildDataSourceSection(cg, query)
-            : { section: '', edgeCount: 0 };
+            : { section: '', edgeCount: 0, sdkImportCount: 0, strongCount: 0 };
         if (dataSourceResult.section)
             lines.push(dataSourceResult.section);
+        const eventDispatchResult = (0, query_utils_1.queryAsEventDispatchSurvey)(query)
+            ? this.buildEventDispatchSection(cg, query, projectRoot)
+            : { section: '', hitCount: 0, eventCount: 0, handlerCount: 0, memberCount: 0, complete: false };
+        if (eventDispatchResult.section)
+            lines.push(eventDispatchResult.section);
         const hoverResult = (0, query_utils_1.shouldBuildHoverHandlerSurvey)(query)
             ? this.buildHoverHandlerSurveySection(cg, query, projectRoot)
             : { section: '', hitCount: 0 };
         if (hoverResult.section)
             lines.push(hoverResult.section);
+        const containerResult = (0, query_utils_1.queryAsContainerCompositionSurvey)(query)
+            ? this.buildContainerCompositionSection(cg, query, projectRoot)
+            : { section: '', hitCount: 0, complete: false };
+        if (containerResult.section)
+            lines.push(containerResult.section);
         const importInventoryFilter = (0, query_utils_1.hasImportInventoryFilter)(query);
         const multiAnchor = (0, query_utils_1.queryNamesMultipleExploreAnchors)(query);
         // Type / caller surveys: skip expensive named-symbol flow synthesize —
@@ -4095,7 +5493,8 @@ class ToolHandler {
         const skipFlow = typeSurface || (0, query_utils_1.queryAsCallerOrMethodSurvey)(query)
             || (0, query_utils_1.queryAsDeclarationSiteSurvey)(query)
             || (0, query_utils_1.queryAsInRepoSystemCapabilityHowto)(query)
-            || (0, query_utils_1.queryAsReturnValueConsumerSurvey)(query);
+            || (0, query_utils_1.queryAsReturnValueConsumerSurvey)(query)
+            || (0, query_utils_1.queryAsEventDispatchSurvey)(query);
         const flow = skipFlow
             ? { pathNodeIds: new Set(), text: '' }
             : this.buildFlowFromNamedSymbols(cg, query);
@@ -4138,7 +5537,8 @@ class ToolHandler {
             || apiUsageResult.section || dataSourceResult.section || hoverResult.section || inheritanceSection
             || callerSection || memberSection || configSection
             || systemCapResult.section || declarationResult.section || moduleDepResult.section
-            || moduleExportResult.section || dtsWrapResult.section || controlSyncResult.section;
+            || moduleExportResult.section || dtsWrapResult.section || controlSyncResult.section
+            || eventDispatchResult.section || containerResult.section;
         if (!hasAnySection)
             return null;
         // Data-source / API usage inventories are complete without source dumps —
@@ -4147,10 +5547,19 @@ class ToolHandler {
             return finishCompact(`System-capability howto — **${systemCapResult.hitCount}** in-repo site(s). **ANSWER NOW** from \`@ohos\`/\`System\` call sites above.`);
         }
         // Declaration intent must NOT fall through to a fat explore / include dump when empty.
+        // Sparse hit lists are Partial locator — hard ANSWER NOW caused D40-style grep storms.
         if (declarationResult.attempted) {
-            return finishCompact(declarationResult.hitCount > 0
-                ? `Declaration-site survey — **${declarationResult.hitCount}** site(s). **ANSWER NOW** from ids + bindings above; do not Grep the same Type.`
-                : 'Declaration-site survey complete (0 sites). **ANSWER NOW** from the note above.');
+            const inventoryAsk = /哪些|分别|各自|哪些文件|id\b|声明|绑定/i.test(query);
+            const sparse = declarationResult.hitCount < 3
+                || (inventoryAsk && declarationResult.hitCount < 6);
+            if (declarationResult.hitCount === 0) {
+                return finishCompact('Declaration-site survey complete (0 sites). **Partial locator** — ONE Grep for the Type constructor is OK.');
+            }
+            if (sparse) {
+                return finishCompact(`Declaration-site survey — **${declarationResult.hitCount}** site(s) (may be incomplete). ` +
+                    '**Partial locator** — narrow Grep for more `id` / constructor sites OK; do not repo-storm.');
+            }
+            return finishCompact(`Declaration-site survey — **${declarationResult.hitCount}** site(s). **ANSWER NOW** from ids + bindings above; do not Grep the same Type.`);
         }
         if (controlSyncResult.section) {
             return finishCompact(`Control/Toggle state-sync survey — **${controlSyncResult.hitCount}** file(s). **ANSWER NOW** from Manager/Service sites above.`);
@@ -4161,7 +5570,10 @@ class ToolHandler {
                 : `Kit module **in-repo usage** — **${kitUsageResult.symbolCount}** imported symbol(s). **ANSWER NOW**; do not Grep the same \`@kit\` path.`);
         }
         if (moduleExportResult.section) {
-            return finishCompact(`NAPI / native export survey — **${moduleExportResult.hitCount}** export(s). **ANSWER NOW**; do not Grep napi_define again.`);
+            return finishCompact(moduleExportResult.shellOnly
+                ? `NAPI / native export survey — Init/Export shells only (**${moduleExportResult.hitCount}**). `
+                    + '**Partial locator** — Read \`napi_property_descriptor\` / \`napi_define_properties\` next.'
+                : `NAPI / native export survey — **${moduleExportResult.hitCount}** export(s). **ANSWER NOW**; do not Grep napi_define again.`);
         }
         if (dtsWrapResult.section) {
             return finishCompact(`\`.d.ts\` wrap call sites — **${dtsWrapResult.hitCount}** file(s). **ANSWER NOW**; do not Grep the wrap basename again.`);
@@ -4170,10 +5582,41 @@ class ToolHandler {
             return finishCompact(`Module dependency / cycle survey — **ANSWER NOW** from the edges above; do not glob every oh-package.`);
         }
         // Data-source intent must stop even when edges=0 (empty still beats a 20k dump).
+        // Hard ANSWER NOW only when same-file @ohos/@kit imports exist — weak/local
+        // edges previously caused false "system service" answers (BadgeManager → %AM*).
         if (dataSourceResult.section && (0, query_utils_1.queryAsDataSourceSurvey)(query)) {
-            return finishCompact(dataSourceResult.edgeCount > 0
-                ? `Data-source survey — **${dataSourceResult.edgeCount}** upstream symbol(s). **ANSWER NOW** from system \`@ohos\`/\`@kit\` imports first.`
-                : 'Data-source survey complete (0 service edges). **ANSWER NOW** from the note + Manager defs above; do not Grep broadly.');
+            if ((0, query_utils_1.queryAsDataSourceDistinguishAsk)(query)) {
+                return finishCompact(dataSourceResult.sdkImportCount > 0
+                    ? `Data-source survey — **${dataSourceResult.sdkImportCount}** \`@ohos\`/\`@kit\` import(s) as anchors. `
+                        + '**Partial locator** — imports alone do not explain unify/distinguish; Read those Manager bodies next.'
+                    : 'Data-source survey — **Partial locator** for unify/distinguish; drill related Managers / narrow Grep next.');
+            }
+            if (dataSourceResult.sdkImportCount > 0) {
+                return finishCompact(`Data-source survey — **${dataSourceResult.sdkImportCount}** \`@ohos\`/\`@kit\` import(s). **ANSWER NOW** from those first.`);
+            }
+            if (dataSourceResult.strongCount > 0) {
+                return finishCompact(`Data-source survey — **${dataSourceResult.strongCount}** related writer/sibling Manager(s). ` +
+                    '**Partial locator** — drill those Types next; do not ANSWER NOW from local cache helpers.');
+            }
+            return finishCompact('Data-source survey complete (0 SDK imports). **Partial locator** — use the note above; ' +
+                'ONE narrow Grep/`homegraph_callers` on update* — not a repo-wide storm.');
+        }
+        if (eventDispatchResult.section && (0, query_utils_1.queryAsEventDispatchSurvey)(query)) {
+            if (eventDispatchResult.complete) {
+                return finishCompact(`Event→Manager dispatch inventory — **${eventDispatchResult.memberCount || eventDispatchResult.eventCount}** `
+                    + `type/member(s), **${eventDispatchResult.handlerCount}** handler file(s). **ANSWER NOW** from the list above.`);
+            }
+            return finishCompact(eventDispatchResult.handlerCount > 0 || eventDispatchResult.eventCount > 0
+                ? `Event→Manager survey — **Partial locator** (`
+                    + `${eventDispatchResult.memberCount} member(s), ${eventDispatchResult.handlerCount} handler file(s)). `
+                    + 'ONE narrow Grep for members/`case`, or one tighter explore — do **not** ANSWER NOW as a full map; no node fan-out.'
+                : 'Event→Manager survey — 0 event types / handlers indexed. **Partial locator** — do **not** ANSWER NOW; '
+                    + 'ONE Grep for enum members / `case` branches OK.');
+        }
+        if (containerResult.section && (0, query_utils_1.queryAsContainerCompositionSurvey)(query)) {
+            return finishCompact(containerResult.complete
+                ? `Container composition survey — **${containerResult.hitCount}** page/site(s). **ANSWER NOW** from injection snippets above; do not Grep \`LocalStorageLink\` again.`
+                : `Container composition survey — **${containerResult.hitCount}** site(s). **Partial locator** — Read the top page file for full build() wiring.`);
         }
         if (apiUsageResult.fileCount > 0 && !dataSourceResult.section) {
             return finishCompact(`API usage survey — **${apiUsageResult.fileCount}** file(s). **ANSWER NOW** from the list above.`);
@@ -4219,8 +5662,11 @@ class ToolHandler {
         if (apiUsageResult.fileCount > 0) {
             return finishCompact(`API usage survey — **${apiUsageResult.fileCount}** file(s). **ANSWER NOW** from the list above.`);
         }
-        if (dataSourceResult.edgeCount > 0) {
-            return finishCompact(`Data-source survey — **${dataSourceResult.edgeCount}** upstream symbol(s). **ANSWER NOW.**`);
+        if (dataSourceResult.sdkImportCount > 0) {
+            return finishCompact(`Data-source survey — **${dataSourceResult.sdkImportCount}** \`@ohos\`/\`@kit\` import(s). **ANSWER NOW.**`);
+        }
+        if (dataSourceResult.strongCount > 0) {
+            return finishCompact(`Data-source survey — **${dataSourceResult.strongCount}** related writer/sibling(s). **Partial locator** — drill next.`);
         }
         if (inheritanceListed) {
             return finishCompact('Inheritance survey above lists all direct subtypes found. **ANSWER NOW** — do not grep `extends`.');
@@ -4281,6 +5727,7 @@ class ToolHandler {
         const isTestPath = (p) => /(^|\/)(tests?|spec)\//i.test(p) || /\.(test|spec)\./i.test(p);
         const fileNodes = new Map();
         const seedIds = new Set();
+        const domainPathTokens = (0, query_utils_1.mechanismDomainPathTokens)(query);
         const addNode = (n) => {
             if ((0, arkts_1.isOhosApiFilePath)(n.filePath))
                 return;
@@ -4294,6 +5741,10 @@ class ToolHandler {
                 list.push(n);
             fileNodes.set(n.filePath, list);
         };
+        // 1) Domain Manager/Service inventory first (static AA class nodes) — locator job.
+        const managerHits = this.collectDomainRoleSymbols(cg, query, domainPathTokens);
+        for (const n of managerHits)
+            addNode(n);
         const domainTermsEarly = (0, query_utils_1.extractDomainSearchTerms)(query);
         const distinctiveEarly = domainTermsEarly.filter((t) => /^[\x00-\x7F]+$/.test(t) && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(t.toLowerCase()));
         // Distinctive-token IMPORT seeds first — `@ohos.convertxml` / `XmlParse*` before
@@ -4323,7 +5774,7 @@ class ToolHandler {
                     }
                 }
                 catch { /* optional */ }
-                if (seedIds.size >= 16)
+                if (seedIds.size >= 20)
                     break;
             }
         }
@@ -4347,8 +5798,6 @@ class ToolHandler {
         }
         if (seedIds.size < 2 || distinctiveEarly.length > 0) {
             const domainTerms = domainTermsEarly;
-            // Prefer distinctive ASCII (xml) then Chinese nouns — never seed on bare verbs
-            // when a distinctive token exists (xml parse → convertxml, not ParseNotification*).
             const distinctive = distinctiveEarly;
             const ranked = distinctive.length > 0
                 ? [
@@ -4382,12 +5831,8 @@ class ToolHandler {
                     const nameHit = nameLc.includes(termLc);
                     const pathHit = pathLc.includes(termLc);
                     const sigHit = sigLc.includes(termLc);
-                    // Verb-only hits need path affinity; imports for verbs are dropped when
-                    // distinctive tokens exist (handled by ranked list above).
                     if (termIsVerb && !pathHit)
                         continue;
-                    // Distinctive token: require name/path/signature to actually mention it
-                    // (drops FTS neighbors that only share an unrelated Parser suffix).
                     if (!termIsVerb && distinctive.length > 0 && !nameHit && !pathHit && !sigHit)
                         continue;
                     const entryOk = r.node.kind === 'import'
@@ -4397,13 +5842,12 @@ class ToolHandler {
                     if (!entryOk)
                         continue;
                     addNode(r.node);
-                    if (seedIds.size >= 16)
+                    if (seedIds.size >= 24)
                         break;
                 }
-                if (seedIds.size >= 12)
+                if (seedIds.size >= 16)
                     break;
             }
-            // Prefer seeds that mention a distinctive token when we have any.
             if (distinctive.length > 0 && seedIds.size > 0) {
                 const keep = new Set();
                 for (const id of seedIds) {
@@ -4412,14 +5856,25 @@ class ToolHandler {
                         continue;
                     const line = n.kind === 'import' ? (0, query_utils_1.resolveImportLineFromNode)(n, projectRoot) : '';
                     const blob = `${n.name}\n${n.filePath}\n${n.signature || ''}\n${line}`.toLowerCase();
-                    if (distinctive.some((t) => blob.includes(t.toLowerCase())))
+                    const hitsDistinctive = distinctive.some((t) => blob.includes(t.toLowerCase()));
+                    const hitsPathTok = domainPathTokens.some((t) => blob.includes(t));
+                    // Domain Manager/Service hits must still match the distinctive stem
+                    // (e.g. `xml`) — otherwise agent EN bags (`xml parser`) keep every
+                    // `*Parser*Manager` that only matched the verb noun.
+                    if ((0, query_utils_1.isDomainRoleSymbol)(n.name, n.filePath, domainPathTokens)) {
+                        if (hitsDistinctive || hitsPathTok)
+                            keep.add(id);
+                        continue;
+                    }
+                    if (hitsDistinctive)
+                        keep.add(id);
+                    if (hitsPathTok)
                         keep.add(id);
                 }
                 if (keep.size > 0) {
                     for (const id of [...seedIds]) {
-                        if (!keep.has(id)) {
+                        if (!keep.has(id))
                             seedIds.delete(id);
-                        }
                     }
                     for (const [fp, nodes] of [...fileNodes.entries()]) {
                         const filtered = nodes.filter((n) => keep.has(n.id));
@@ -4435,18 +5890,33 @@ class ToolHandler {
             return null;
         const seeds = (0, query_utils_1.extractMechanismEntrySeeds)(query);
         const flow = this.buildFlowFromNamedSymbols(cg, `${query} ${seeds.join(' ')}`);
+        const hasFlowPath = flow.pathNodeIds.size > 1;
+        const managerSection = this.formatDomainRoleInventory(managerHits.length > 0
+            ? managerHits
+            : [...seedIds].map((id) => cg.getNode(id)).filter((n) => !!n && (0, query_utils_1.isDomainRoleSymbol)(n.name, n.filePath, domainPathTokens)));
+        const hasStrongManager = managerSection.strongCount > 0;
+        // Inventory without a connected spine is a locator — hard ANSWER NOW caused
+        // Partial→re-explore / Grep storms after a correct first anchor.
+        const mechanismClosed = hasFlowPath && (hasStrongManager || seeds.length >= 2);
         const lines = [
             `**Exploration: ${query}**`,
             '',
-            '> **ANSWER NOW from this response.** Do **not** Grep or Read listed files in parallel — Source below is authoritative.',
+            mechanismClosed
+                ? '> **ANSWER NOW from this response** when the Manager inventory + mechanism spine cover the ask. '
+                    + 'Do **not** Grep/Read listed files in parallel — Source below is authoritative.'
+                : '> **Partial locator** — Manager / domain inventory below are anchors, not a full mechanism closure. '
+                    + 'Pick **ONE** concrete `*Manager` / next-hop name from the list for a tighter explore — '
+                    + 'do **not** re-explore a paraphrase of the same keyword bag. '
+                    + 'At most one `homegraph_node` after Partial; prefer ONE narrow Grep for unlisted wiring — not a repo storm. '
+                    + 'Do **not** ANSWER NOW yet.',
             '',
             `Mechanism anchors: **${seedIds.size}** symbol(s) — lightweight explore (seed + flow spine).`,
             '',
         ];
-        // Import inventory: prefer concrete API seeds (convertxml / XmlParseUtil) over
-        // bare domain tokens like `xml` that flood every path containing the substring.
+        if (managerSection.text)
+            lines.push(managerSection.text);
         const seedImportFocus = (0, query_utils_1.extractMechanismEntrySeeds)(query).filter((s) => !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(s.toLowerCase())
-            && (s.length >= 6 || /convert|xml|parse|manager|service/i.test(s)));
+            && s.length >= 5);
         const distinctiveDeps = (0, query_utils_1.extractDependencySymbolsFromQuery)(query)
             .filter((s) => !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(s.toLowerCase()));
         const importQuery = (seedImportFocus.length > 0
@@ -4454,19 +5924,22 @@ class ToolHandler {
             : distinctiveDeps.length > 0
                 ? distinctiveDeps
                 : (0, query_utils_1.extractDomainSearchTerms)(query)
-                    .filter((t) => /^[\x00-\x7F]+$/.test(t) && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(t.toLowerCase()))).slice(0, 4).join(' ');
+                    .filter((t) => /^[\x00-\x7F]+$/.test(t) && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(t.toLowerCase()) && t.length >= 3)).slice(0, 4).join(' ');
         const importResult = importQuery
             ? this.buildImportSitesSection(cg, importQuery, projectRoot)
             : { section: '', siteCount: 0, compactListing: false };
-        // Light path: keep ≤8 import bullets (full inventory belongs to kit/API surveys).
         if (importResult.section) {
-            const trimmed = this.trimLightImportSection(importResult.section, 8);
+            // Wider + path-diversified when a distinctive stem exists (e.g. xml→convertxml
+            // usages span backup/ + util/ — first-N-only hid judge keypoints).
+            const importBullets = distinctiveEarly.length > 0 ? 8 : 5;
+            const trimmed = this.trimLightImportSection(importResult.section, importBullets);
             if (trimmed)
                 lines.push(trimmed);
         }
-        if (flow.text)
+        if (flow.text) {
+            lines.push('**Mechanism spine**', '');
             lines.push(flow.text);
-        // Shared-lib + GLES/EGL thread: surface CMake link lines before bodies.
+        }
         if ((0, query_utils_1.queryAsNativeRenderThreadSurvey)(query)) {
             const cmakeHits = [];
             try {
@@ -4474,12 +5947,6 @@ class ToolHandler {
                     const fp = f.path.replace(/\\/g, '/');
                     if (!/CMakeLists\.txt$/i.test(fp))
                         continue;
-                    if (!/foldeffect|effectrender|render|egl/i.test(fp) && (0, query_utils_1.extractPathSegmentsFromQuery)(query).length > 0) {
-                        const segs = (0, query_utils_1.extractPathSegmentsFromQuery)(query);
-                        if (!segs.some((s) => fp.toLowerCase().includes(s.toLowerCase().split('/').pop() || s))) {
-                            // still allow any CMake with GLESv3/EGL
-                        }
-                    }
                     const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, f.path);
                     if (!abs)
                         continue;
@@ -4510,27 +5977,44 @@ class ToolHandler {
                 lines.push('');
             }
         }
-        const distinctiveForScore = (0, query_utils_1.extractDomainSearchTerms)(query).filter((t) => /^[\x00-\x7F]+$/.test(t) && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(t.toLowerCase()));
-        const apiSeeds = (0, query_utils_1.extractMechanismEntrySeeds)(query).map((s) => s.toLowerCase());
+        const distinctiveForScore = (0, query_utils_1.extractDomainSearchTerms)(query).filter((t) => /^[\x00-\x7F]+$/.test(t) && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(t.toLowerCase()) && t.length >= 3);
+        const apiSeeds = (0, query_utils_1.extractMechanismEntrySeeds)(query)
+            .map((s) => s.toLowerCase())
+            .filter((s) => s.length >= 5 && !query_utils_1.GENERIC_VERB_ANCHOR_NOISE.has(s));
         const fileScores = new Map();
         for (const [fp, nodes] of fileNodes) {
             if ((0, arkts_1.isOhosApiFilePath)(fp))
                 continue;
+            if ((0, query_utils_1.isTestFile)(fp))
+                continue;
             let score = 0;
-            const fpLc = fp.toLowerCase();
+            const fpLc = fp.toLowerCase().replace(/\\/g, '/');
             if (distinctiveForScore.some((t) => fpLc.includes(t.toLowerCase())))
                 score += 30;
-            // Prefer real wrappers (XmlParseUtil / convertxml) over incidental Xml* paths.
-            if (apiSeeds.some((s) => s.length >= 6 && fpLc.includes(s)))
+            if (apiSeeds.some((s) => fpLc.includes(s)))
                 score += 40;
-            if (/convertxml|xmlparseutil/i.test(fpLc))
-                score += 50;
+            for (const t of domainPathTokens) {
+                if (t.length >= 4 && fpLc.includes(`/${t}/`))
+                    score += 60;
+                if (t.length >= 4 && fpLc.includes(t))
+                    score += 20;
+            }
+            if ((0, query_utils_1.queryAsNativeRenderThreadSurvey)(query)) {
+                if (/plugin_manager|egl_core|nativerender|xcomponent|render_service/i.test(fpLc))
+                    score += 90;
+                if (/\.cpp$|\.h$|cmake/i.test(fpLc))
+                    score += 25;
+            }
             for (const n of nodes) {
                 const line = n.kind === 'import' ? (0, query_utils_1.resolveImportLineFromNode)(n, projectRoot) : '';
                 const blob = `${n.name}\n${n.signature || ''}\n${line}`.toLowerCase();
+                if ((0, query_utils_1.isDomainRoleSymbol)(n.name, n.filePath, domainPathTokens))
+                    score += 80;
+                if (/Manager|Subscriber|Listener$/i.test(n.name) && /\/manager\//i.test(fpLc))
+                    score += 40;
                 if (distinctiveForScore.some((t) => blob.includes(t.toLowerCase())))
                     score += 20;
-                if (apiSeeds.some((s) => s.length >= 6 && blob.includes(s)))
+                if (apiSeeds.some((s) => blob.includes(s)))
                     score += 25;
                 if (n.kind === 'import'
                     && distinctiveForScore.some((t) => {
@@ -4539,7 +6023,7 @@ class ToolHandler {
                     })) {
                     score += 20;
                 }
-                if (/convertxml|@kit\.|@ohos\./i.test(line))
+                if (/@kit\.|@ohos\./i.test(line))
                     score += 30;
                 if (flow.pathNodeIds.has(n.id))
                     score += 20;
@@ -4548,57 +6032,325 @@ class ToolHandler {
                 else
                     score += 5;
             }
+            // Demote incidental restore/settings hits when a domain path token exists.
+            if (domainPathTokens.length > 0 && /restore|settings|statusbar/i.test(fpLc)
+                && !domainPathTokens.some((t) => fpLc.includes(`/${t}/`))) {
+                score = Math.max(0, score - 40);
+            }
             fileScores.set(fp, score);
         }
         const sortedFiles = [...fileScores.entries()]
             .filter(([, s]) => s > 0)
             .sort((a, b) => b[1] - a[1])
             .slice(0, 3);
-        lines.push('**Source Code**', '');
-        lines.push('> Line-numbered source below — treat as already Read. Do **not** grep/read/`homegraph_node` these files again.');
+        // Prefer digests for the best domain-role Type (not import-site top file).
+        const nextMgr = (0, explore_repeat_guard_1.pickBestDomainRoleAnchor)(managerHits.map((n) => ({
+            name: n.name,
+            kind: n.kind,
+            filePath: n.filePath,
+            startLine: n.startLine,
+        })), query, domainPathTokens);
+        if (nextMgr?.filePath) {
+            const pref = nextMgr.filePath;
+            const rest = sortedFiles.filter(([fp]) => fp !== pref);
+            const prefScore = fileScores.get(pref) ?? 100;
+            sortedFiles.length = 0;
+            sortedFiles.push([pref, prefScore], ...rest.slice(0, 2));
+        }
+        const topIsStrong = sortedFiles.some(([fp, s]) => {
+            if (s < 80)
+                return false;
+            const nodes = fileNodes.get(fp) ?? [];
+            return nodes.some((n) => (0, query_utils_1.isDomainRoleSymbol)(n.name, n.filePath, domainPathTokens));
+        });
+        lines.push('**Source digests**', '');
+        lines.push('> Spine / top-hit digests — treat as already Read for these symbols. '
+            + 'ONE narrow Grep/Read only for residual unindexed wiring; do not dump these files again.');
         lines.push('');
+        // Anchor table before digests (universal mid-lean shape).
+        if (sortedFiles.length > 0) {
+            lines.push('**Anchors**', '');
+            for (const [fp] of sortedFiles.slice(0, 6)) {
+                const nodes = fileNodes.get(fp) ?? [];
+                const names = nodes
+                    .filter((n) => n.kind !== 'import' && n.kind !== 'export')
+                    .slice(0, 4)
+                    .map((n) => `\`${n.name}\`(${n.kind}${n.startLine ? `:${n.startLine}` : ''})`)
+                    .join(', ');
+                lines.push(`- \`${fp}\`${names ? ` — ${names}` : ''}`);
+            }
+            lines.push('');
+        }
         let totalChars = lines.join('\n').length;
         let filesRendered = 0;
+        const digest = exploreLocatorDigestEnabled();
+        const perFileCap = digest ? 2800 : 2000;
+        const totalCap = digest ? 6500 : 4_800;
         for (const [fp] of sortedFiles) {
-            // Token budget: light howto must stay ~3–5k so explore+answer can beat Grep/Read.
-            if (filesRendered >= 2 || totalChars > 4_800)
+            if (filesRendered >= 2 || totalChars > totalCap)
                 break;
-            const chunk = this.renderLightMechanismSource(projectRoot, fp, fileNodes.get(fp) ?? [], 2000);
+            const chunk = this.renderLightMechanismSource(projectRoot, fp, fileNodes.get(fp) ?? [], perFileCap);
             if (!chunk)
                 continue;
-            lines.push(chunk);
-            totalChars += chunk.length;
-            filesRendered++;
+            lines.push(chunk);
+            totalChars += chunk.length;
+            filesRendered++;
+        }
+        if (filesRendered === 0 && !importResult.section && !flow.text && !managerSection.text)
+            return null;
+        // Soft-close when inventory + at least one digest exist — enough to answer
+        // with ONE narrow Grep; avoid Partial→re-explore churn.
+        // Also close when distinctive-stem import evidence + digests exist but no
+        // *Manager* survived filtering (xml/convertxml how-implemented bags).
+        const digestCoversNext = !!(nextMgr && sortedFiles.some(([fp]) => fp === nextMgr.filePath)
+            && filesRendered > 0);
+        const importEvidenceClose = distinctiveEarly.length > 0
+            && importResult.siteCount >= 3
+            && filesRendered >= 1;
+        const xmlStem = distinctiveEarly.some((t) => t.toLowerCase() === 'xml');
+        const bodyText = lines.join('\n');
+        const xmlMechanismClose = xmlStem
+            && filesRendered >= 1
+            && /convertxml|ConvertXML|fastConvertToJSObject/i.test(bodyText);
+        const nativeRenderClose = (0, query_utils_1.queryAsNativeRenderThreadSurvey)(query)
+            && filesRendered >= 1
+            && (/plugin_manager|egl_core|OnSurfaceCreated|EGLCore|nativerender/i.test(bodyText)
+                || /\*\*CMake \/ link \+ GL libs\*\*/.test(bodyText));
+        // Don't soft-close onto an antithetical Primary (Delete* while ask is install/parse).
+        const nextContradictsPipeline = !!(nextMgr
+            && /(?:解析|安装|激活|下载|parse|install|activate|download)/i.test(query)
+            && (/^(?:Delete|Remove|Uninstall|Clear|Cancel)/i.test(nextMgr.name)
+                || /Delete|Uninstall|RemoveOnline|CancelRestore/i.test(nextMgr.name)));
+        const softClose = !nextContradictsPipeline && ((hasStrongManager && filesRendered >= 1
+            && (digestCoversNext || managerHits.length >= 2 || topIsStrong))
+            || importEvidenceClose
+            || xmlMechanismClose
+            || nativeRenderClose);
+        const closedAnswer = softClose || mechanismClosed || (hasFlowPath && topIsStrong);
+        lines.push('---');
+        if (mechanismClosed || (hasFlowPath && topIsStrong)) {
+            lines.push('> **Mechanism explore complete — ANSWER NOW** from the Manager inventory + spine + digests above. '
+                + 'Do **not** call `homegraph_node`, Read, or Grep for symbols/files already shown. '
+                + 'Only one tighter `homegraph_explore` if a **named** Type essential to the answer is still missing.');
+        }
+        else if (softClose) {
+            lines.push((0, explore_repeat_guard_1.formatMechanismSoftCloseFooter)(nextMgr));
+        }
+        else {
+            const topFp = sortedFiles[0]?.[0];
+            const topNodes = topFp ? (fileNodes.get(topFp) ?? []) : [];
+            const topSym = topNodes.find((n) => n.kind !== 'import' && n.kind !== 'export' && n.startLine > 0)
+                ?? topNodes[0];
+            const nextCaption = nextMgr
+                ? (0, explore_repeat_guard_1.formatNextAnchorCaption)(nextMgr)
+                : topSym
+                    ? (0, explore_repeat_guard_1.formatNextAnchorCaption)({
+                        name: topSym.name,
+                        kind: topSym.kind,
+                        filePath: topSym.filePath,
+                        startLine: topSym.startLine,
+                    })
+                    : topFp
+                        ? `\`${topFp}\``
+                        : 'the top Manager / file in the inventory above';
+            lines.push((0, explore_repeat_guard_1.formatMechanismPartialFooter)(nextCaption));
+        }
+        // Opening banner is emitted before digests; rewrite so soft-close never
+        // pairs a Partial header with an ANSWER footer (agent Grep-storm trigger).
+        if (closedAnswer) {
+            const openIdx = lines.findIndex((l) => l.includes('**Partial locator**') || l.includes('**ANSWER NOW from this response**'));
+            if (openIdx >= 0) {
+                lines[openIdx] = softClose && !(mechanismClosed || (hasFlowPath && topIsStrong))
+                    ? (0, explore_repeat_guard_1.formatMechanismSoftCloseHeader)()
+                    : ('> **ANSWER NOW from this response** when the Manager inventory + mechanism spine cover the ask. '
+                        + 'Do **not** Grep/Read listed files in parallel — Source below is authoritative.');
+            }
+        }
+        lines.push('');
+        const text = lines.join('\n');
+        return this.exploreResult(text, {
+            projectRoot,
+            query,
+            files: [],
+            sourceBytes: 0,
+            responseBytes: text.length,
+            // Soft-close must not trip Partial→depth fuse / next-anchor churn.
+            partial: closedAnswer ? false : undefined,
+            nextAnchor: closedAnswer ? undefined : (nextMgr?.name),
+        });
+    }
+    /**
+     * Static AA class/interface nodes that look like domain Managers/Services.
+     */
+    collectDomainRoleSymbols(cg, query, domainTokens) {
+        const tokens = domainTokens.length > 0
+            ? domainTokens
+            : (0, query_utils_1.mechanismDomainPathTokens)(query);
+        if (tokens.length === 0)
+            return [];
+        const byId = new Map();
+        const tryAdd = (n) => {
+            if ((0, arkts_1.isOhosApiFilePath)(n.filePath) || (0, query_utils_1.isTestFile)(n.filePath))
+                return;
+            if (n.kind !== 'class' && n.kind !== 'struct' && n.kind !== 'interface' && n.kind !== 'component')
+                return;
+            if (!(0, query_utils_1.isDomainRoleSymbol)(n.name, n.filePath, tokens))
+                return;
+            byId.set(n.id, n);
+        };
+        for (const seed of (0, query_utils_1.extractMechanismEntrySeeds)(query)) {
+            if (seed.startsWith('@'))
+                continue;
+            try {
+                for (const n of cg.getNodesByName(seed))
+                    tryAdd(n);
+            }
+            catch { /* */ }
+        }
+        for (const t of tokens.slice(0, 6)) {
+            let hits = [];
+            try {
+                hits = cg.searchNodes(t, { kinds: ['class', 'struct', 'interface', 'component'], limit: 30 });
+            }
+            catch {
+                continue;
+            }
+            for (const r of hits)
+                tryAdd(r.node);
+        }
+        // Also probe Manager suffix via FTS when a domain token is present.
+        for (const suffix of ['Manager', 'Subscriber', 'Listener']) {
+            let hits = [];
+            try {
+                hits = cg.searchNodes(suffix, { kinds: ['class', 'interface', 'component'], limit: 40 });
+            }
+            catch {
+                continue;
+            }
+            for (const r of hits) {
+                if (tokens.some((t) => {
+                    const tl = t.toLowerCase();
+                    const blob = `${r.node.name}\n${r.node.filePath}`.toLowerCase();
+                    return blob.includes(tl);
+                })) {
+                    tryAdd(r.node);
+                }
+            }
         }
-        if (filesRendered === 0 && !importResult.section && !flow.text)
-            return null;
-        lines.push('---');
-        lines.push('> **Mechanism explore complete — ANSWER NOW.** Sections above cover the wired mechanism. ' +
-            'Do **not** call `homegraph_node`, Read, or Grep for symbols/files already shown (that multiplies tokens). ' +
-            'Only one tighter `homegraph_explore` if a **named** symbol essential to the answer is still missing.');
+        const themeFocus = tokens.some((t) => /theme/i.test(t));
+        return [...byId.values()]
+            .filter((n) => {
+            if (!themeFocus)
+                return true;
+            const blob = `${n.name}\n${n.filePath}`.toLowerCase().replace(/\\/g, '/');
+            // Theme-pack questions: drop app-install / desktop-download Managers.
+            if (/themeservice|themepack|\/theme|themepackparser|themeactivate|themeinfo|themevip/i.test(blob)) {
+                return true;
+            }
+            if (/appinstall|installermanager|installdatamanager|installevent|downloadaction/i.test(blob)) {
+                return false;
+            }
+            return true;
+        })
+            .sort((a, b) => {
+            const score = (n) => {
+                let s = 0;
+                const fp = n.filePath.toLowerCase().replace(/\\/g, '/');
+                if (/\/manager\//i.test(fp))
+                    s += 5;
+                if (/Subscribe|Listener|Bridge/i.test(n.name))
+                    s += 3;
+                if (/Manager$/i.test(n.name))
+                    s += 2;
+                for (const t of tokens) {
+                    if (fp.includes(`/${t}/`))
+                        s += 8;
+                    if (n.name.toLowerCase().includes(t))
+                        s += 4;
+                }
+                if (themeFocus) {
+                    if (/themeservice|themepack/i.test(fp) || /ThemePack|ThemePackage|ThemeActivate|ThemeInfo/i.test(n.name)) {
+                        s += 25;
+                    }
+                    if (/appinstall|bigfolder.*download/i.test(fp) && !/theme/i.test(fp + n.name)) {
+                        s -= 20;
+                    }
+                }
+                return s;
+            };
+            return score(b) - score(a) || a.name.localeCompare(b.name);
+        })
+            .slice(0, 12);
+    }
+    formatDomainRoleInventory(nodes) {
+        if (nodes.length === 0)
+            return { text: '', strongCount: 0 };
+        const rel = (p) => p.replace(/\\/g, '/');
+        const lines = [
+            '**Domain Manager / Service inventory** (static index — locator anchors)',
+            '',
+            '> Prefer these Types for the next explore or the answer. Do not Grep the domain noun across the repo.',
+            '',
+        ];
+        for (const n of nodes.slice(0, 10)) {
+            lines.push(`- \`${n.name}\` (${n.kind}) — \`${rel(n.filePath)}:${n.startLine}\``);
+        }
+        if (nodes.length > 10)
+            lines.push(`- … and ${nodes.length - 10} more`);
         lines.push('');
-        return this.textResult(lines.join('\n'));
+        return { text: lines.join('\n'), strongCount: nodes.length };
     }
-    /** Cap import bullets inside a light-mechanism response. */
+    /** Cap import bullets inside a light-mechanism response; prefer non-test paths. */
     trimLightImportSection(section, maxBullets) {
         const lines = section.split('\n');
-        const out = [];
-        let bullets = 0;
-        let truncated = false;
+        const header = [];
+        const prod = [];
+        const test = [];
         for (const line of lines) {
             if (line.startsWith('- `')) {
-                if (bullets >= maxBullets) {
-                    truncated = true;
-                    continue;
-                }
-                bullets++;
+                const pathMatch = line.match(/^- `([^`]+)`/);
+                const fp = pathMatch?.[1]?.split(':')[0] ?? '';
+                if (fp && (0, query_utils_1.isTestFile)(fp))
+                    test.push(line);
+                else
+                    prod.push(line);
             }
-            if (/^\s*- … and \d+ more/i.test(line))
+            else if (/^\s*- … and \d+ more/i.test(line)) {
                 continue;
-            out.push(line);
-        }
-        if (truncated) {
-            out.push(`- … (light-mechanism: showing ${maxBullets} sites — **ANSWER NOW**, do not Grep the same import)`);
+            }
+            else {
+                header.push(line);
+            }
+        }
+        // Round-robin across top path prefixes so one product/ folder cannot hide
+        // other convertxml / kit usage sites (backup vs util vs launchercommon).
+        const diversify = (items, max) => {
+            const buckets = new Map();
+            for (const line of items) {
+                const pathMatch = line.match(/^- `([^`]+)`/);
+                const fp = (pathMatch?.[1]?.split(':')[0] ?? '').replace(/\\/g, '/');
+                const parts = fp.split('/').filter(Boolean);
+                const key = parts.length >= 3 ? `${parts[0]}/${parts[1]}/${parts[2]}` : (parts.length >= 2 ? `${parts[0]}/${parts[1]}` : (parts[0] || fp || '_'));
+                const list = buckets.get(key) ?? [];
+                list.push(line);
+                buckets.set(key, list);
+            }
+            const keys = [...buckets.keys()];
+            const out = [];
+            let i = 0;
+            while (out.length < max && keys.some((k) => (buckets.get(k)?.length ?? 0) > 0)) {
+                const k = keys[i % keys.length];
+                const list = buckets.get(k);
+                if (list && list.length > 0)
+                    out.push(list.shift());
+                i++;
+            }
+            return out;
+        };
+        const chosen = diversify([...prod, ...test], maxBullets);
+        const out = [...header, ...chosen];
+        if (prod.length + test.length > maxBullets) {
+            out.push(`- … (light-mechanism: showing ${maxBullets} sites, tests deprioritized — **ANSWER NOW**, do not Grep the same import)`);
         }
         return out.join('\n');
     }
@@ -4687,6 +6439,7 @@ class ToolHandler {
         const typeNameSet = new Set(typeNames.map((t) => t.toLowerCase()));
         const bridge = (0, query_utils_1.queryNeedsCoNamedUseBridge)(query);
         const memberFocus = (0, query_utils_1.queryHasNamedMemberFocus)(query);
+        const uiConsequence = (0, query_utils_1.queryAsMemberUiConsequenceSurvey)(query);
         const uiCluster = (0, query_utils_1.queryAsFocusedUiCluster)(query);
         const typeLifecycle = (0, query_utils_1.queryAsTypeLifecycleSurvey)(query);
         const componentSurface = (0, query_utils_1.queryAsComponentSurfaceSurvey)(query)
@@ -4892,16 +6645,118 @@ class ToolHandler {
                 // skip edge trail for this seed
             }
         }
+        // Prefer dropping SDK `.d.ts` seeds entirely when any in-repo impl exists for
+        // the same name; if remaining source files are stub-only, soften ANSWER NOW.
+        // Named Type that only exists as stub → soft even when NL leftovers add project seeds (D59).
+        const isStubPath = (fp) => (0, arkts_1.isOhosApiFilePath)(fp) || /\.d\.ts$/i.test(fp);
+        let stubSeedCount = 0;
+        let projectSeedCount = 0;
+        for (const id of seedIds) {
+            try {
+                const n = cg.getNode(id);
+                if (!n)
+                    continue;
+                if (isStubPath(n.filePath))
+                    stubSeedCount++;
+                else
+                    projectSeedCount++;
+            }
+            catch { /* */ }
+        }
+        const primaryNames = (0, query_utils_1.extractTypeNamesFromQuery)(query).filter((t) => !(0, query_utils_1.isFrameworkUiDecoratorName)(t));
+        let primaryStubOnly = false;
+        for (const name of primaryNames.slice(0, 4)) {
+            let nodes = [];
+            try {
+                nodes = cg.getNodesByName(name).filter((n) => !(0, query_utils_1.isTestFile)(n.filePath));
+            }
+            catch {
+                continue;
+            }
+            if (nodes.length === 0)
+                continue;
+            if (nodes.every((n) => isStubPath(n.filePath))) {
+                primaryStubOnly = true;
+                break;
+            }
+        }
+        // Drop stub bodies from the source dump when a project def of the same name exists.
+        // If the *named* Type is stub-only, keep soft framing even if other project seeds remain.
+        const projectFilesPresent = [...fileNodes.keys()].some((fp) => !isStubPath(fp));
+        if (projectFilesPresent && !primaryStubOnly) {
+            for (const fp of [...fileNodes.keys()]) {
+                if (isStubPath(fp))
+                    fileNodes.delete(fp);
+            }
+        }
+        const stubHeavy = primaryStubOnly
+            || (stubSeedCount > 0 && projectSeedCount === 0)
+            || (fileNodes.size > 0 && [...fileNodes.keys()].every((fp) => isStubPath(fp)));
+        const implAsk = /状态机|state\s*machine|foreground|background|回调|callback|转换|trigger/i.test(query);
+        // Property / resource provenance ($r vs download) — compact body alone is rarely enough.
+        const resourceProvenanceAsk = /\$r\b|系统资源|网络下载|resource\s+vs|vs\.?\s*network|download\s+or|preview|预览|图片加载|loadImage|PixelMap|Image\s*\(/i.test(query);
+        // Multi-Type bags without a connected flow are coarse locators — never fake-complete.
+        const multiTypeThin = typeNames.length >= 2
+            && !(0, query_utils_1.queryHasNamedMemberFocus)(query)
+            && !(0, query_utils_1.queryAsNamedComponentAction)(query);
+        let lifecycleStubComplete = false;
+        let lifecycleStubSection = '';
+        if (typeLifecycle && stubHeavy) {
+            const stubPaths = [...fileNodes.keys()].filter(isStubPath);
+            const lifecycleResult = this.buildSdkStubLifecycleSection(projectRoot, stubPaths, query);
+            lifecycleStubSection = lifecycleResult.section;
+            lifecycleStubComplete = lifecycleResult.complete;
+        }
         const lines = [
             `**Exploration: ${query}**`,
             '',
-            '> **ANSWER NOW from this response.** Do **not** Grep/Read/search/explore/node/callers for the same symbols — trail + Source below are authoritative.',
+            lifecycleStubComplete
+                ? '> **Coarse locate complete — SDK lifecycle inventory below.** **ANSWER NOW** from state enum + callbacks; '
+                    + 'do not Grep in-repo or re-explore the same stub names.'
+                : stubHeavy
+                    ? '> **Partial locator** — indexed hits are SDK / `.d.ts` stubs, not in-repo implementations. '
+                        + 'Prefer `homegraph_search` / ONE explore for `*State*` / impl class names; '
+                        + 'ONE narrow Grep for in-repo impl names is OK — do not ANSWER NOW from the stub alone.'
+                    : resourceProvenanceAsk
+                        ? '> **Coarse locate — check Source digests for `$r` / Image / download.** '
+                            + 'Treat visible bodies as already Read. ONE narrow Grep for `$r`/`http` only if digests lack load origin — '
+                            + 'do **not** re-explore or fan out Read on the same Page/Dialog.'
+                        : multiTypeThin
+                            ? '> **Partial locator** — multi-Type bag below is a coarse anchor set. '
+                                + 'Pick ONE Type/`Type.member` for a tighter explore, or ONE narrow Grep for unindexed wiring — do **not** ANSWER NOW as a full cross-Type mechanism.'
+                            : '> **Coarse locate complete.** Treat Source + trail as already Read for these symbols. '
+                                + 'Answer from them; do **not** re-Grep/Read/node the same symbols. '
+                                + 'ONE narrow Grep is OK only for residual literals / unindexed wiring — not a repo-wide storm.',
             '',
             `Local-symbol focus: **${seedIds.size}** seed(s)` +
                 (neighborIds.size > 0 ? `, **${neighborIds.size}** caller/callee neighbor(s)` : '') +
                 ' — compact explore (definition + edge trail, no related-file dump).',
             '',
         ];
+        if (lifecycleStubSection)
+            lines.push(lifecycleStubSection);
+        if (stubHeavy && implAsk && !lifecycleStubComplete) {
+            lines.push('> Stub-only compact — state/callback answers usually live in project `.ets` / `.ts` under the feature, not `@ohos.*.d.ts`.', '');
+        }
+        // Bare `BadgeManager`-style compact: surface real @ohos/@kit / sibling Managers.
+        // Never dump anonymous `%AM*` / local cache callees as "upstream services".
+        const managerSeeds = names.filter((n) => /(?:Manager|Service|Handler|Store)$/i.test(n));
+        if (managerSeeds.length > 0) {
+            const ds = this.buildDataSourceSection(cg, `${managerSeeds.join(' ')} 数据来源于哪个系统服务`);
+            if (ds.section) {
+                lines.push(ds.section);
+                if (ds.sdkImportCount === 0) {
+                    // Soften hard compact complete — cache-layer Managers otherwise look "done".
+                    const softIdx = lines.findIndex((l) => l.includes('**Coarse locate complete.**') || l.includes('**ANSWER NOW from this response.**'));
+                    if (softIdx >= 0) {
+                        lines[softIdx] =
+                            '> **Partial locator** — Manager body + trail below are anchors. ' +
+                                'Do **not** treat local cache/RDB helpers as the system service; ' +
+                                'follow related Managers / `homegraph_callers` on `update*` next, or ONE narrow Grep for the service name.';
+                    }
+                }
+            }
+        }
         // Blast radius for entry seeds (locations only) — same signal full explore
         // always-on section gives, so bare-name edits know what to update/verify.
         {
@@ -4970,10 +6825,30 @@ class ToolHandler {
             }
             if (trailBullets > 0) {
                 trail.push('');
-                trail.push('> **ANSWER NOW** from this trail + Source below. Do not grep/search/read the same symbols again.');
+                trail.push(stubHeavy
+                    ? '> Trail above may reference stubs — prefer in-repo impl files; do not ANSWER NOW from `.d.ts` alone.'
+                    : '> Prefer these call/use sites + Source below. Do not re-Grep/Read the same symbols; '
+                        + 'ONE narrow Grep only for residual unindexed wiring.');
                 trail.push('');
                 lines.push(...trail);
             }
+            else if (!stubHeavy
+                && !resourceProvenanceAsk
+                && !multiTypeThin
+                // UI Page/Dialog surfaces + member text-usage already answer without a
+                // graph trail — flipping to Partial caused ThemeHome/isExpired fan-out
+                // (163355 flat-but-worse-cost / score drops).
+                && !componentSurface
+                && !uiCluster
+                && !memberFocus) {
+                // No graph trail — coarse locate only; do not claim completeness.
+                const softIdx = lines.findIndex((l) => l.includes('**Coarse locate complete.**'));
+                if (softIdx >= 0) {
+                    lines[softIdx] =
+                        '> **Partial locator** — definition anchors below, no call/use trail in the graph. '
+                            + 'ONE tighter explore on a callee/caller name, or ONE narrow Grep for registration — not a repo-wide storm.';
+                }
+            }
         }
         // When the graph has no call edges (common for static Type.member reads),
         // fall back to a bounded indexed-file text scan for `name(` usages so the
@@ -5101,7 +6976,10 @@ class ToolHandler {
                 }
                 lines.push('');
                 lines.push(memberFocus
-                    ? '> These lines are the in-repo **call/filter sites** for the named member. **ANSWER NOW** from them + Source — do not Grep/`homegraph_callers` the same member.'
+                    ? uiConsequence
+                        ? '> UI-consequence ask: call/filter sites above show **how true/expired values affect UI** '
+                            + '(often exclusion from render stacks). **ANSWER NOW** from them + Source — do not Read/Grep the same member.'
+                        : '> These lines are the in-repo **call/filter sites** for the named member. **ANSWER NOW** from them + Source — do not Grep/`homegraph_callers` the same member.'
                     : '> These lines are the in-repo use sites. Answer from them + Source; do not grep the same names again.');
                 lines.push('');
             }
@@ -5179,7 +7057,7 @@ class ToolHandler {
                 // (FormStack…) burns tokens and invites a follow-up Read of isExpired.
                 ? 1
                 : ((0, query_utils_1.queryAsNamedComponentAction)(query) || componentSurface || usageFiles.size > 0 || bridge)
-                    ? (uiCluster ? 2 : (componentSurface ? 2 : 3))
+                    ? (uiCluster ? 2 : (componentSurface ? 2 : (exploreLocatorDigestEnabled() ? 2 : 3)))
                     : 2;
         const ranked = [...fileNodes.entries()]
             .filter(([, nodes]) => {
@@ -5208,26 +7086,35 @@ class ToolHandler {
         })
             .sort((a, b) => b.score - a.score || a.fp.localeCompare(b.fp))
             .slice(0, maxFiles);
-        lines.push('**Source Code**', '');
-        lines.push('> Line-numbered source — treat as already Read. **ANSWER NOW** — do not Read/Grep/search/explore/node the same symbols again.');
+        const digest = exploreLocatorDigestEnabled();
+        lines.push(digest ? '**Source digests**' : '**Source Code**', '');
+        lines.push(stubHeavy && !lifecycleStubComplete
+            ? '> Stub digests only — treat as Partial locator. Do **not** ANSWER NOW from `.d.ts` alone; search in-repo impl next.'
+            : digest
+                ? '> Short digests — treat as already Read for these symbols. Answer from anchors + digests; '
+                    + 'ONE narrow Grep only for residual unindexed wiring.'
+                : '> Line-numbered source — treat as already Read. **ANSWER NOW** — do not Read/Grep/search/explore/node the same symbols again.');
         lines.push('');
         let totalChars = lines.join('\n').length;
-        // Lean ceilings: without-HG Grep/Read stacks were ~15k session tokens; a 10–14k
-        // compact body + follow-up Read is what loses the token A/B.
-        const maxTotal = bareMemberOnly
-            ? 4500
-            : componentSurface || uiCluster
-                ? 7000
-                : memberFocus && usageFiles.size > 0
-                    ? 6500
-                    : 5500;
-        const maxPerFile = bareMemberOnly
-            ? 2800
-            : componentSurface || uiCluster
+        // Locator-digest ceilings (0012): keep compact under Grep/Read stacks.
+        const maxTotal = digest
+            ? (bareMemberOnly ? 3600 : componentSurface || uiCluster ? 5500 : memberFocus && usageFiles.size > 0 ? 5000 : 4800)
+            : (bareMemberOnly
                 ? 4500
-                : memberFocus
-                    ? 2800
-                    : 3200;
+                : componentSurface || uiCluster
+                    ? 7000
+                    : memberFocus && usageFiles.size > 0
+                        ? 6500
+                        : 5500);
+        const maxPerFile = digest
+            ? (bareMemberOnly ? 2000 : componentSurface || uiCluster ? 2800 : memberFocus ? 2500 : 2800)
+            : (bareMemberOnly
+                ? 2800
+                : componentSurface || uiCluster
+                    ? 4500
+                    : memberFocus
+                        ? 2800
+                        : 3200);
         let rendered = 0;
         for (const { fp, nodes } of ranked) {
             if (rendered >= maxFiles || totalChars > maxTotal)
@@ -5376,26 +7263,255 @@ class ToolHandler {
         }
         if (rendered === 0)
             return null;
+        // If provenance digests already show $r / download / PixelMap, kill any leftover
+        // Partial banner so the agent stops (163355 D17 Partial→Read fan-out).
+        if (resourceProvenanceAsk) {
+            const body = lines.join('\n');
+            if (/\$r\b|PixelMap|copyFile|http[s]?:|download|getPreview|previewPixelMap/i.test(body)) {
+                const softIdx = lines.findIndex((l) => l.includes('**Partial locator**'));
+                if (softIdx >= 0) {
+                    lines[softIdx] =
+                        '> **Coarse locate complete.** Source digests already show load origin (`$r` / download / PixelMap). '
+                            + '**ANSWER NOW** — do not Read/Grep the same Page/Dialog again.';
+                }
+            }
+        }
         lines.push('---');
         lines.push('> **Compact local explore complete — ANSWER NOW.** ' +
             'Do **not** Read/Grep/`homegraph_search`/`homegraph_explore`/`homegraph_node` for the same symbols.');
         lines.push('');
         return this.textResult(lines.join('\n'));
     }
+    /**
+     * When a lifecycle Type only exists as SDK `.d.ts`, extract state enums +
+     * callback registrations from the stub so agents stop grep-storming in-repo.
+     */
+    buildSdkStubLifecycleSection(projectRoot, stubFilePaths, _query) {
+        const rel = (p) => p.replace(/\\/g, '/');
+        const enums = [];
+        const callbacks = [];
+        for (const fp of stubFilePaths.slice(0, 4)) {
+            const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, fp);
+            if (!abs || !(0, fs_1.existsSync)(abs))
+                continue;
+            let content = '';
+            try {
+                content = (0, fs_1.readFileSync)(abs, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const fileLines = content.split('\n');
+            for (let i = 0; i < fileLines.length; i++) {
+                const line = fileLines[i] ?? '';
+                if (/^\s*enum\s+\w*State\w*\s*\{/.test(line)) {
+                    const members = [];
+                    for (let j = i + 1; j < Math.min(fileLines.length, i + 48); j++) {
+                        const l = fileLines[j] ?? '';
+                        if (/^\s*\}/.test(l))
+                            break;
+                        const m = l.match(/^\s*(\w+)\s*[,=]/);
+                        if (m?.[1])
+                            members.push(m[1]);
+                    }
+                    if (members.length > 0) {
+                        enums.push(`\`${line.trim().slice(0, 72)}\` → ${members.slice(0, 14).join(', ')}`);
+                    }
+                }
+                if (/on\s*\(\s*type\s*:\s*['"][\w]+['"]/.test(line)
+                    || /Register the callback|Register.*Callback|move scene session|foreground|background|sessionStateChange/i.test(line)) {
+                    callbacks.push(`- \`${rel(fp)}:${i + 1}\`  \`${line.trim().slice(0, 110)}\``);
+                }
+            }
+        }
+        if (enums.length === 0 && callbacks.length < 3) {
+            return { section: '', complete: false };
+        }
+        const lines = [
+            '**SDK lifecycle surface (indexed stub)**',
+            '',
+            '> Lifecycle Type is stub-only — state enum + callbacks below are authoritative. **ANSWER NOW**; '
+                + 'do not Grep in-repo for the same SDK API names.',
+            '',
+        ];
+        if (enums.length > 0) {
+            lines.push('**State enum(s)**', '');
+            for (const e of enums.slice(0, 4))
+                lines.push(`- ${e}`);
+            lines.push('');
+        }
+        if (callbacks.length > 0) {
+            lines.push('**Callbacks / transitions**', '');
+            lines.push(...callbacks.slice(0, 22));
+            if (callbacks.length > 22)
+                lines.push(`- … and ${callbacks.length - 22} more`);
+            lines.push('');
+        }
+        const complete = enums.length > 0 && callbacks.length >= 3;
+        return { section: lines.join('\n'), complete: complete || callbacks.length >= 6 };
+    }
+    /**
+     * Pages sharing a container component + how they inject differentiated
+     * ViewModel / LocalStorage state into the shared shell.
+     */
+    buildContainerCompositionSection(cg, query, projectRoot) {
+        const types = (0, query_utils_1.extractTypeNamesFromQuery)(query).filter((t) => !(0, query_utils_1.isFrameworkUiDecoratorName)(t));
+        const containerName = types.find((t) => /(?:Screen|Page|View|Container)$/i.test(t))
+            ?? types.find((t) => /Screen/i.test(t))
+            ?? types[0];
+        const viewModelName = types.find((t) => /ViewModel$/i.test(t));
+        if (!containerName)
+            return { section: '', hitCount: 0, complete: false };
+        const rel = (p) => p.replace(/\\/g, '/');
+        const hits = [];
+        const seen = new Set();
+        const ingestFile = (fp, content, baseScore) => {
+            if (seen.has(fp) || (0, query_utils_1.isTestFile)(fp))
+                return;
+            if (!content.includes(containerName))
+                return;
+            const useRe = new RegExp(`${containerName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*[({]`);
+            if (!useRe.test(content) && !content.includes(`import { ${containerName}`))
+                return;
+            const fileLines = content.split('\n');
+            const snippets = [];
+            for (let i = 0; i < fileLines.length; i++) {
+                const line = fileLines[i] ?? '';
+                if (line.includes(containerName)
+                    || /@LocalStorageLink|LocalStorageProp|screenSession/i.test(line)
+                    || (viewModelName && line.includes(viewModelName))
+                    || /new\s+\w+ViewModel/i.test(line)) {
+                    snippets.push(`L${i + 1}: ${line.trim().slice(0, 100)}`);
+                    if (snippets.length >= 4)
+                        break;
+                }
+            }
+            if (snippets.length === 0)
+                return;
+            seen.add(fp);
+            let score = baseScore;
+            if (/@LocalStorageLink/i.test(content))
+                score += 30;
+            if (/CommonScbView|EntryView|DevView/i.test(fp))
+                score += 20;
+            if (viewModelName && content.includes(viewModelName))
+                score += 15;
+            hits.push({ file: fp, snippet: snippets.join(' / '), score });
+        };
+        let results = [];
+        try {
+            results = cg.searchNodes(containerName, { kinds: ['import', 'component', 'class', 'struct'], limit: 36 });
+        }
+        catch { /* */ }
+        for (const r of results) {
+            if ((0, arkts_1.isOhosApiFilePath)(r.node.filePath))
+                continue;
+            const fp = rel(r.node.filePath);
+            if (!/\.(ets|tsx|jsx|vue|svelte)$/i.test(fp))
+                continue;
+            const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, r.node.filePath);
+            if (!abs)
+                continue;
+            let content = '';
+            try {
+                content = (0, fs_1.readFileSync)(abs, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            ingestFile(fp, content, 12);
+        }
+        if (hits.length < 4) {
+            try {
+                for (const f of cg.getFiles()) {
+                    if (hits.length >= 14)
+                        break;
+                    const fp = rel(f.path);
+                    if (!/\.ets$/i.test(fp))
+                        continue;
+                    const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, f.path);
+                    if (!abs)
+                        continue;
+                    let content = '';
+                    try {
+                        content = (0, fs_1.readFileSync)(abs, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    ingestFile(fp, content, 8);
+                }
+            }
+            catch { /* optional */ }
+        }
+        hits.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
+        if (hits.length === 0)
+            return { section: '', hitCount: 0, complete: false };
+        const lines = [
+            '**Container composition / ViewModel injection survey**',
+            '',
+            `> Pages using \`${containerName}\`${viewModelName ? ` with \`${viewModelName}\`` : ''}. `
+                + '**ANSWER NOW** from injection snippets — do not fan out Read/callers per page.',
+            '',
+        ];
+        for (const h of hits.slice(0, 10)) {
+            lines.push(`- \`${h.file}\` — ${h.snippet.slice(0, 220)}`);
+        }
+        if (hits.length > 10)
+            lines.push(`- … and ${hits.length - 10} more`);
+        lines.push('');
+        const complete = hits.length >= 2
+            && hits.some((h) => /@LocalStorageLink|screenSession|ViewModel/i.test(h.snippet));
+        return { section: lines.join('\n'), hitCount: Math.min(hits.length, 10), complete };
+    }
     /**
      * Hover / pointer-handler inventory — onHover / Hover* symbols + short snippets.
      * Used when the agent asks about hover effects without naming a Type yet.
      */
     buildHoverHandlerSurveySection(cg, query, projectRoot) {
         const topicBoost = /图标|icon|appicon|dock|launcher/i.test(query);
-        const searchTerms = ['onHover', 'HoverAnimation', 'HoverEffect', 'HoverConstants', 'hover'];
+        const searchTerms = topicBoost
+            ? [
+                'onHover', 'AppIconCommonView', 'HoverAnimationUtil', 'AppIconHoverEvent',
+                'setIconHoverEventIface', 'HoverAnimation', 'HoverEffect',
+            ]
+            : ['onHover', 'HoverAnimation', 'HoverEffect', 'HoverConstants', 'hover'];
         const seen = new Set();
         const hits = [];
+        const scoreHit = (r, term, snippet) => {
+            const nameLc = r.node.name.toLowerCase();
+            const pathLc = r.node.filePath.toLowerCase().replace(/\\/g, '/');
+            const termLc = term.toLowerCase();
+            let score = nameLc === 'onhover' || nameLc.startsWith('onhover') ? 40 : 10;
+            if (/hover/.test(nameLc))
+                score += 15;
+            if (/onhover/.test(snippet.toLowerCase()))
+                score += 35;
+            if (/appiconcommonview|hoveranimationutil|appiconhover/i.test(nameLc))
+                score += 45;
+            if (/seticonhover|geticonhover/i.test(nameLc))
+                score += 35;
+            if (topicBoost && /launchercommon|launchericon|appicon|smartdock|appcenter/i.test(pathLc)) {
+                score += 50;
+            }
+            if (topicBoost && /controlcenter|commonconstants|controlpanel/i.test(pathLc)) {
+                score -= 45;
+            }
+            if (topicBoost && nameLc === 'hoverconstants' && !/launcher|appicon/i.test(pathLc)) {
+                score -= 40;
+            }
+            if (topicBoost && /import/.test(snippet) && !/onhover|hoveranimation|appicon/i.test(snippet.toLowerCase())) {
+                score -= 25;
+            }
+            if (termLc === 'onhover' && /component|struct/.test(r.node.kind))
+                score += 10;
+            return score;
+        };
         for (const term of searchTerms) {
             let results = [];
             try {
                 results = cg.searchNodes(term, {
-                    kinds: ['method', 'function', 'property', 'field', 'variable', 'constant', 'class', 'component'],
+                    kinds: ['method', 'function', 'property', 'field', 'variable', 'constant', 'class', 'component', 'struct'],
                     limit: 30,
                 });
             }
@@ -5414,11 +7530,6 @@ class ToolHandler {
                 if (seen.has(key))
                     continue;
                 seen.add(key);
-                let score = nameLc === 'onhover' || nameLc.startsWith('onhover') ? 40 : 10;
-                if (/hover/.test(nameLc))
-                    score += 15;
-                if (topicBoost && /icon|appicon|dock|launcher|smartdock|appcenter/i.test(pathLc))
-                    score += 25;
                 let snippet = (r.node.signature || r.node.name).slice(0, 120);
                 try {
                     const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, r.node.filePath);
@@ -5430,12 +7541,38 @@ class ToolHandler {
                     }
                 }
                 catch { /* keep signature */ }
+                // App icon views often expose `.onHover` on a builder line — scan nearby.
+                if (topicBoost && /appiconcommonview/i.test(pathLc)) {
+                    try {
+                        const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, r.node.filePath);
+                        if (abs && (0, fs_1.existsSync)(abs)) {
+                            const lines = (0, fs_1.readFileSync)(abs, 'utf-8').split('\n');
+                            for (let i = 0; i < lines.length; i++) {
+                                if (!/\.onHover\s*\(/.test(lines[i] ?? ''))
+                                    continue;
+                                const hk = `${r.node.filePath}:${i + 1}:onHover`;
+                                if (seen.has(hk))
+                                    continue;
+                                seen.add(hk);
+                                hits.push({
+                                    file: r.node.filePath,
+                                    line: i + 1,
+                                    name: 'onHover',
+                                    kind: 'property',
+                                    score: 90,
+                                    snippet: (lines[i] ?? '').trim().slice(0, 160),
+                                });
+                            }
+                        }
+                    }
+                    catch { /* optional */ }
+                }
                 hits.push({
                     file: r.node.filePath,
                     line: r.node.startLine,
                     name: r.node.name,
                     kind: r.node.kind,
-                    score,
+                    score: scoreHit(r, term, snippet),
                     snippet,
                 });
             }
@@ -5454,20 +7591,32 @@ class ToolHandler {
             };
         }
         hits.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
+        // Icon-hover asks: drop import-only control-center noise from the visible set.
+        const filtered = topicBoost
+            ? hits.filter((h) => {
+                const pl = h.file.toLowerCase();
+                if (h.score >= 35)
+                    return true;
+                if (/controlcenter|commonconstants/.test(pl) && h.name === 'HoverConstants')
+                    return false;
+                return h.score > 0;
+            })
+            : hits;
+        const displayHits = filtered.length > 0 ? filtered : hits;
         const lines = [
             '**Hover / pointer handler survey**',
             '',
             '> **ANSWER NOW** from these in-repo hover handlers + snippets. Do not Grep `onHover` again unless a named Type is still missing.',
             '',
         ];
-        const shown = hits.slice(0, 12);
+        const shown = displayHits.slice(0, 12);
         for (const h of shown) {
             lines.push(`- \`${h.name}\` (${h.kind}) — \`${h.file}:${h.line}\``);
             if (h.snippet)
                 lines.push(`  \`${h.snippet.slice(0, 100)}\``);
         }
-        if (hits.length > shown.length)
-            lines.push(`- … and ${hits.length - shown.length} more`);
+        if (displayHits.length > shown.length)
+            lines.push(`- … and ${displayHits.length - shown.length} more`);
         lines.push('');
         return { section: lines.join('\n'), hitCount: shown.length };
     }
@@ -5618,8 +7767,8 @@ class ToolHandler {
                 lines.push(`- \`${sym}\` — imported in ${fileList}${more}`);
             }
         }
-        // "需要额外安装哪些依赖" — surface oh-package.json5 lines naming the kit.
-        if (/额外安装|还需.*依赖|需要.*依赖|install(?:ing)?\s+(?:extra\s+)?deps?|which\s+deps?/i.test(query)) {
+        // Install/deps asks (incl. agent EN "parameters dependencies") — oh-package lines.
+        if ((0, query_utils_1.queryAsksKitInstallDeps)(query)) {
             const depLines = [];
             try {
                 for (const f of cg.getFiles()) {
@@ -6013,7 +8162,7 @@ class ToolHandler {
         for (const typeName of types) {
             let hits = [];
             try {
-                hits = cg.searchNodes(typeName, { limit: 80 });
+                hits = cg.searchNodes(typeName, { limit: 200 });
             }
             catch {
                 continue;
@@ -6036,16 +8185,29 @@ class ToolHandler {
                     continue;
                 files.set(abs, rel(r.node.filePath));
             }
+            // Import sites of the Type — JSX construction often lives in the same file.
+            try {
+                for (const r of cg.searchNodes(typeName, { kinds: ['import'], limit: 80 })) {
+                    if ((0, query_utils_1.isTestFile)(r.node.filePath) || (0, arkts_1.isOhosApiFilePath)(r.node.filePath))
+                        continue;
+                    const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, r.node.filePath);
+                    if (!abs || !(0, fs_1.existsSync)(abs))
+                        continue;
+                    files.set(abs, rel(r.node.filePath));
+                }
+            }
+            catch { /* optional */ }
             // Framework UI tags (XComponent…) often have no indexed symbol at the JSX
-            // site — expand to sibling .ets under the same feature/staticcommon roots
-            // already touched by native/header hits.
+            // site — expand to sibling .ets under the same feature/staticcommon/product roots
+            // already touched by hits/imports.
             const featureRoots = new Set();
             for (const fp of files.values()) {
-                const m = fp.match(/^(feature\/[^/]+|staticcommon\/[^/]+)/);
+                const m = fp.match(/^(feature\/[^/]+|staticcommon\/[^/]+|product\/[^/]+)/);
                 if (m?.[1])
                     featureRoots.add(m[1]);
             }
-            if (featureRoots.size > 0 && featureRoots.size <= 6) {
+            const inventoryAsk = /哪些|分别|各自|哪些文件|id\b|声明/i.test(query);
+            if (featureRoots.size > 0 && featureRoots.size <= (inventoryAsk ? 24 : 6)) {
                 try {
                     for (const f of cg.getFiles()) {
                         const fp = rel(f.path);
@@ -6119,23 +8281,32 @@ class ToolHandler {
                 section: [
                     '**Declaration / id / native-binding survey**',
                     '',
-                    `> No UI/native construction sites for \`${types.join('`, `')}\` in the index. **ANSWER NOW** — do not Grep the same Type for "declaration"; at most one Grep for \`<${types[0]}\` if you must.`,
+                    `> No UI/native construction sites for \`${types.join('`, `')}\` in the index. **Partial locator** — ` +
+                        `ONE Grep for \`<${types[0]}\` / \`${types[0]}(\` is OK; do not repo-storm.`,
                     '',
                 ].join('\n'),
                 hitCount: 0,
                 attempted: true,
             };
         }
+        const hitCount = Math.min(rows.length, 20);
+        // Sparse inventories (1–2 sites) are incomplete for "哪些文件/id/分别" — never hard ANSWER NOW.
+        const inventoryAsk = /哪些|分别|各自|哪些文件|id\b|声明|绑定/i.test(query);
+        const sparse = hitCount < 3 || (inventoryAsk && hitCount < 6);
+        const guidance = sparse
+            ? `> Construction / JSX / \`id\` / native register sites above (**${hitCount}**). **Partial locator** — ` +
+                'list may be incomplete; ONE narrow Grep for more `id:` / `XComponent(` sites is OK.'
+            : '> Construction / JSX / `id` / native register sites. **ANSWER NOW** — do not Grep the same Type again.';
         return {
             section: [
                 '**Declaration / id / native-binding survey**',
                 '',
-                '> Construction / JSX / `id` / native register sites. **ANSWER NOW** — do not Grep the same Type again.',
+                guidance,
                 '',
                 ...rows.slice(0, 20),
                 '',
             ].join('\n'),
-            hitCount: Math.min(rows.length, 20),
+            hitCount,
             attempted: true,
         };
     }
@@ -6144,7 +8315,7 @@ class ToolHandler {
         const rawSymbols = (0, query_utils_1.extractApiUsageTokens)(query).slice(0, 6);
         if (rawSymbols.length === 0)
             return { section: '', fileCount: 0 };
-        // Expand Telephony → telephony / @ohos.telephony so import call sites hit.
+        // Expand Telephony → telephony / @ohos.telephony / @kit.TelephonyKit call sites.
         const symbols = [];
         for (const sym of rawSymbols) {
             symbols.push(sym);
@@ -6157,6 +8328,12 @@ class ToolHandler {
                     symbols.push(ohos);
             }
         }
+        if (rawSymbols.some((s) => /^telephony$/i.test(s))) {
+            for (const kit of ['@kit.TelephonyKit', '@hms.telephony.enhanced', '@hms.telephony.vsim', 'TelephonyKit']) {
+                if (!symbols.includes(kit))
+                    symbols.push(kit);
+            }
+        }
         const rel = (p) => p.replace(/\\/g, '/');
         const hits = new Map();
         const addHit = (file, line) => {
@@ -6170,8 +8347,54 @@ class ToolHandler {
             prev.stub = prev.stub && stub;
             hits.set(fp, prev);
         };
-        for (const sym of symbols.slice(0, 6)) {
+        if (rawSymbols.some((s) => /^telephony$/i.test(s))) {
+            for (const kit of ['@kit.TelephonyKit', '@hms.telephony.enhanced', '@hms.telephony.vsim']) {
+                let importHits = [];
+                try {
+                    importHits = cg.searchNodes(kit.replace(/^@/, ''), { kinds: ['import'], limit: 40 });
+                }
+                catch {
+                    importHits = [];
+                }
+                for (const r of importHits) {
+                    const line = (0, query_utils_1.resolveImportLineFromNode)(r.node, projectRoot);
+                    if (line.includes(kit) || line.toLowerCase().includes(kit.toLowerCase())) {
+                        addHit(r.node.filePath, r.node.startLine);
+                    }
+                }
+                // FTS stem fallback (`TelephonyKit`, `telephony.vsim`, …).
+                const stem = kit.split('.').pop() ?? kit;
+                try {
+                    importHits = cg.searchNodes(stem, { kinds: ['import'], limit: 40 });
+                }
+                catch {
+                    importHits = [];
+                }
+                for (const r of importHits) {
+                    const line = (0, query_utils_1.resolveImportLineFromNode)(r.node, projectRoot);
+                    if (line.includes('@kit.TelephonyKit') || line.includes('@hms.telephony')) {
+                        addHit(r.node.filePath, r.node.startLine);
+                    }
+                }
+            }
+        }
+        for (const sym of symbols.slice(0, 8)) {
             const symLc = sym.toLowerCase();
+            if (sym.startsWith('@')) {
+                let importNodes = [];
+                try {
+                    importNodes = cg.searchNodes(sym.replace(/^@/, ''), { kinds: ['import'], limit: 28 });
+                }
+                catch {
+                    importNodes = [];
+                }
+                for (const r of importNodes) {
+                    const line = (0, query_utils_1.resolveImportLineFromNode)(r.node, projectRoot).toLowerCase();
+                    if (line.includes(symLc.replace(/^@/, '')) || line.includes(symLc)) {
+                        addHit(r.node.filePath, r.node.startLine);
+                    }
+                }
+            }
             let nodes = [];
             try {
                 nodes = cg.searchNodes(sym.replace(/^@/, ''), { limit: 40 });
@@ -6270,6 +8493,14 @@ class ToolHandler {
         const rankedFiles = [...hits.entries()].sort((a, b) => {
             if (a[1].stub !== b[1].stub)
                 return a[1].stub ? 1 : -1;
+            const telephonyBoost = (fp) => rawSymbols.some((s) => /^telephony$/i.test(s))
+                && /@kit\.telephonykit|@hms\.telephony|telephonykit/i.test(fp.toLowerCase())
+                ? -1
+                : 0;
+            const ta = telephonyBoost(a[0]);
+            const tb = telephonyBoost(b[0]);
+            if (ta !== tb)
+                return ta - tb;
             return a[0].localeCompare(b[0]);
         });
         const projectHits = rankedFiles.filter(([, v]) => !v.stub);
@@ -6307,9 +8538,17 @@ class ToolHandler {
             }
         }
         // Recompute display after call-site enrichment.
+        const telephonyBoost = (fp) => rawSymbols.some((s) => /^telephony$/i.test(s))
+            && /@kit\.telephonykit|@hms\.telephony|telephonykit/i.test(fp.toLowerCase())
+            ? -1
+            : 0;
         const rankedFiles2 = [...hits.entries()].sort((a, b) => {
             if (a[1].stub !== b[1].stub)
                 return a[1].stub ? 1 : -1;
+            const ta = telephonyBoost(a[0]);
+            const tb = telephonyBoost(b[0]);
+            if (ta !== tb)
+                return ta - tb;
             return a[0].localeCompare(b[0]);
         });
         const projectHits2 = rankedFiles2.filter(([, v]) => !v.stub);
@@ -6363,6 +8602,34 @@ class ToolHandler {
                 lines.push(`- … and ${methodNames.size - 24} more`);
             lines.push('');
         }
+        if (rawSymbols.some((s) => /^telephony$/i.test(s))) {
+            const kitSurfaces = new Set();
+            for (const [fp, info] of display2.slice(0, 40)) {
+                const abs = (0, utils_1.validatePathWithinRoot)(projectRoot, fp);
+                if (!abs || !(0, fs_1.existsSync)(abs))
+                    continue;
+                let fileLines = [];
+                try {
+                    fileLines = (0, fs_1.readFileSync)(abs, 'utf-8').split('\n');
+                }
+                catch {
+                    continue;
+                }
+                for (const ln of info.lines.slice(0, 8)) {
+                    const lineText = fileLines[ln - 1] ?? '';
+                    for (const m of lineText.matchAll(/@kit\.TelephonyKit|@hms\.telephony(?:\.\w+)?/g)) {
+                        if (m[0])
+                            kitSurfaces.add(m[0]);
+                    }
+                }
+            }
+            if (kitSurfaces.size > 0) {
+                lines.push('**@kit / @hms Telephony imports**');
+                for (const k of [...kitSurfaces].sort())
+                    lines.push(`- \`${k}\``);
+                lines.push('');
+            }
+        }
         let shown = 0;
         const isImportish = (s) => /^\s*import\b/.test(s) || /\bfrom\s+['"]@/.test(s);
         const isLifetimeish = (s) => /\b(?:new|delete|free|reset)\b/i.test(s) || /=\s*new\b/.test(s);
@@ -6733,11 +9000,24 @@ class ToolHandler {
         }
         const cg = this.getHomeGraph(args.projectPath);
         const projectRoot = cg.getProjectRoot();
+        // Same-bag / call-budget refuse (session view injected by execute).
+        const sessionPrior = (0, explore_session_state_1.viewForProject)((0, explore_session_state_1.readExploreSessionView)(args), projectRoot);
+        const repeat = (0, explore_repeat_guard_1.decideExploreRepeat)(sessionPrior, query);
+        if (repeat.refuse) {
+            const text = (0, explore_repeat_guard_1.formatExploreRepeatRefuse)(repeat, query);
+            return this.exploreResult(text, {
+                projectRoot,
+                query,
+                files: [],
+                sourceBytes: 0,
+                responseBytes: text.length,
+            });
+        }
         const compactLocal = this.tryFastInventoryExplore(cg, query, projectRoot)
             ?? this.tryLightMechanismExplore(cg, query, projectRoot)
             ?? this.tryCompactLocalSymbolExplore(cg, query, projectRoot);
         if (compactLocal)
-            return compactLocal;
+            return this.ensureExploreEmission(compactLocal, projectRoot, query);
         // Light mechanism already attempted above.
         // Resolve adaptive output budget from project size.
         // largest-tier defaults if stats aren't available, which preserves
@@ -7406,7 +9686,11 @@ class ToolHandler {
                 'production handlers are out of scope unless explicitly referenced in the test.');
             lines.push('');
         }
-        const importResult = (0, query_utils_1.queryAsksKitInstallDeps)(query)
+        const importResult = ((0, query_utils_1.queryAsksKitInstallDeps)(query)
+            || (0, query_utils_1.queryAsEventDispatchSurvey)(query)
+            || (0, query_utils_1.queryAsOutOfRepoSdkCatalog)(query)
+            || (0, query_utils_1.queryAsKitModuleCapabilitySurvey)(query)
+            || (0, query_utils_1.queryAsDataSourceSurvey)(query))
             ? { section: '', siteCount: 0, compactListing: false }
             : this.buildImportSitesSection(cg, query, projectRoot);
         if (importResult.section)
@@ -7434,9 +9718,14 @@ class ToolHandler {
             lines.push(apiUsageResult.section);
         const dataSourceResult = (0, query_utils_1.queryAsDataSourceSurvey)(query)
             ? this.buildDataSourceSection(cg, query)
-            : { section: '', edgeCount: 0 };
+            : { section: '', edgeCount: 0, sdkImportCount: 0, strongCount: 0 };
         if (dataSourceResult.section)
             lines.push(dataSourceResult.section);
+        const eventDispatchResult = (0, query_utils_1.queryAsEventDispatchSurvey)(query)
+            ? this.buildEventDispatchSection(cg, query, projectRoot)
+            : { section: '', hitCount: 0, eventCount: 0, handlerCount: 0, memberCount: 0, complete: false };
+        if (eventDispatchResult.section)
+            lines.push(eventDispatchResult.section);
         const importInventoryFilter = (0, query_utils_1.hasImportInventoryFilter)(query);
         const multiAnchor = (0, query_utils_1.queryNamesMultipleExploreAnchors)(query) || crossModuleFlow;
         const mechanismSurvey = (0, query_utils_1.queryAsMechanismSurvey)(query);
@@ -7521,6 +9810,12 @@ class ToolHandler {
             if (configSection) {
                 return finishCompact('Config/manifest content above — answer from it directly.');
             }
+            if (eventDispatchResult.section && (0, query_utils_1.queryAsEventDispatchSurvey)(query)) {
+                if (eventDispatchResult.complete) {
+                    return finishCompact(`Event→Manager dispatch inventory — **${eventDispatchResult.handlerCount}** handler file(s). **ANSWER NOW**.`);
+                }
+                return finishCompact('Event→Manager survey incomplete. **Partial locator** — do **not** ANSWER NOW as a full dispatch map.');
+            }
             if (kitUsageResult.section) {
                 return finishCompact(`Kit module **in-repo usage** survey — **${kitUsageResult.symbolCount}** imported symbol(s). ` +
                     'Not an SDK catalog. **ANSWER NOW** from the usage list; do not Grep the same `@kit` path.');
@@ -7534,8 +9829,11 @@ class ToolHandler {
             if (listedTypeMethods && callerBulletCount > 0) {
                 return finishCompact(`Caller inventory — **${callerBulletCount}** site(s) for listed methods. **ANSWER NOW**; do not fan out callers per method.`);
             }
-            if (dataSourceResult.section && dataSourceResult.edgeCount > 0) {
-                return finishCompact(`Data-source survey — **${dataSourceResult.edgeCount}** upstream symbol(s). **ANSWER NOW.**`);
+            if (dataSourceResult.section && dataSourceResult.sdkImportCount > 0) {
+                return finishCompact(`Data-source survey — **${dataSourceResult.sdkImportCount}** \`@ohos\`/\`@kit\` import(s). **ANSWER NOW.**`);
+            }
+            if (dataSourceResult.section && dataSourceResult.strongCount > 0) {
+                return finishCompact(`Data-source survey — **${dataSourceResult.strongCount}** related writer/sibling(s). **Partial locator** — drill next.`);
             }
             if (inheritanceListed) {
                 return finishCompact('Inheritance survey above lists all direct subtypes found. **ANSWER NOW** — do not grep `extends`.');
@@ -7645,15 +9943,6 @@ class ToolHandler {
             }
             return false;
         };
-        lines.push('**Source Code**');
-        lines.push('');
-        // Recorded so the drift pass below (#1474) can append a per-file exception
-        // to this guarantee after the render loop knows which files drifted.
-        const verbatimHeaderIdx = lines.length;
-        lines.push('> Line-numbered source — treat as already Read. Answer from Flow + Source below when you can; ' +
-            'do not re-read/grep these files, and do not fan out `homegraph_node` / search for symbols already shown. ' +
-            'Another `homegraph_explore` with tighter names only if a needed symbol is missing.');
-        lines.push('');
         let totalChars = lines.join('\n').length;
         let filesIncluded = 0;
         // Paths we actually render source for below. Drives the curated header count
@@ -7712,9 +10001,19 @@ class ToolHandler {
             if (onSpine.length > 0)
                 filesToRender = onSpine;
         }
-        const sourceFileCap = limitSingleFile && filesToRender.length === 1
-            ? 1
-            : localDetail
+        const sourceFileCap = (() => {
+            const digest = exploreLocatorDigestEnabled();
+            if (limitSingleFile && filesToRender.length === 1)
+                return 1;
+            if (digest) {
+                // Locator digest: at most 2 body digests (spine/named); rest stay as path anchors.
+                if (localDetail)
+                    return Math.min(maxFiles, 2);
+                if (hasFlowPath)
+                    return Math.min(maxFiles, 2);
+                return Math.min(maxFiles, 2);
+            }
+            return localDetail
                 ? Math.min(maxFiles, 2)
                 : crossModuleFlow && hasFlowPath
                     ? Math.min(maxFiles, 5)
@@ -7725,6 +10024,38 @@ class ToolHandler {
                             : !hasFlowPath
                                 ? Math.min(maxFiles, 3)
                                 : maxFiles;
+        })();
+        // Path-only anchors for files we will not dump as Source (digest mode).
+        if (exploreLocatorDigestEnabled()) {
+            const anchorCap = Math.min(filesToRender.length, 10);
+            lines.push('**Anchors**', '');
+            for (const [fp, group] of filesToRender.slice(0, anchorCap)) {
+                const names = group.nodes
+                    .filter((n) => n.kind !== 'import' && n.kind !== 'export')
+                    .slice(0, 4)
+                    .map((n) => `\`${n.name}\`(${n.kind}${n.startLine ? `:${n.startLine}` : ''})`)
+                    .join(', ');
+                lines.push(`- \`${fp}\`${names ? ` — ${names}` : ''}`);
+            }
+            if (filesToRender.length > sourceFileCap) {
+                lines.push('');
+                lines.push(`> Body digests only for the top **${sourceFileCap}** file(s) below; remaining anchors are path-only.`);
+            }
+            lines.push('');
+        }
+        lines.push(exploreLocatorDigestEnabled() ? '**Source digests**' : '**Source Code**');
+        lines.push('');
+        // Recorded so the drift pass below (#1474) can append a per-file exception
+        // to this guarantee after the render loop knows which files drifted.
+        const verbatimHeaderIdx = lines.length;
+        lines.push(exploreLocatorDigestEnabled()
+            ? '> Spine / top-hit digests — treat as already Read. '
+                + 'Answer from Flow + Anchors + digests when you can; ONE narrow Grep for residual unindexed wiring. '
+                + 'Do not re-dump these files via Read/`homegraph_node`.'
+            : '> Line-numbered source — treat as already Read. Answer from Flow + Source below when you can; ' +
+                'do not re-read/grep these files, and do not fan out `homegraph_node` / search for symbols already shown. ' +
+                'Another `homegraph_explore` with tighter names only if a needed symbol is missing.');
+        lines.push('');
         for (const [filePath, group] of filesToRender) {
             if (filesIncluded >= sourceFileCap)
                 break;
@@ -8183,7 +10514,7 @@ class ToolHandler {
             // token cost on small projects. We pick clusters in priority order
             // until the per-file char cap is hit. Truly enormous single clusters
             // get tail-trimmed with a marker.
-            const contextPadding = 3;
+            const contextPadding = exploreLocatorDigestEnabled() ? 2 : 3;
             // Language-neutral separator (no `//` — not a comment in Python, Ruby,
             // etc.). With line numbers on, the line-number jump also signals the gap.
             const GAP_MARKER = '\n\n... (gap) ...\n\n';
@@ -8193,10 +10524,11 @@ class ToolHandler {
             // for any per-file cap and gets dropped, so the agent Reads the method back —
             // the exact gap this closes. Bounded, so a god-method can't blow the budget yet
             // the spine's call still appears in context.
-            const OVERSIZE_SPINE_LINES = 200;
-            const OVERSIZE_BODY_LINES = 160;
-            const SPINE_WINDOW = 28; // lines each side of the next-hop call site
-            const BODY_WINDOW = 40;
+            const digest = exploreLocatorDigestEnabled();
+            const OVERSIZE_SPINE_LINES = digest ? 120 : 200;
+            const OVERSIZE_BODY_LINES = digest ? 100 : 160;
+            const SPINE_WINDOW = digest ? 18 : 28; // lines each side of the next-hop call site
+            const BODY_WINDOW = digest ? 24 : 40;
             const buildSectionRange = (c) => {
                 const span = c.end - c.start + 1;
                 if (c.hasSpine && c.spineCallLine && span > OVERSIZE_SPINE_LINES) {
@@ -8268,7 +10600,7 @@ class ToolHandler {
             // path is the answer), but bounded — at most ~2.5× the per-file cap and never
             // past what's left of the total output cap — so a pathological long in-file
             // spine can't run away or starve co-flow files entirely.
-            const SPINE_CEILING = Math.min(budget.maxCharsPerFile * 2.5, remainingEnvelope);
+            const SPINE_CEILING = Math.min(budget.maxCharsPerFile * (exploreLocatorDigestEnabled() ? 1.5 : 2.5), remainingEnvelope);
             const chosenIndices = new Set();
             let projectedChars = 0;
             for (const rc of rankedClusters) {
@@ -8554,8 +10886,39 @@ class ToolHandler {
      * calling session's state and deletes it — see {@link EXPLORE_EMISSION_KEY}.
      */
     exploreResult(text, emission) {
+        const meta = (0, explore_repeat_guard_1.inferExplorePartialMeta)(text);
         const result = this.textResult(text);
-        result[explore_session_state_1.EXPLORE_EMISSION_KEY] = emission;
+        result[explore_session_state_1.EXPLORE_EMISSION_KEY] = {
+            ...emission,
+            partial: emission.partial ?? meta.partial,
+            nextAnchor: emission.nextAnchor ?? meta.nextAnchor,
+        };
+        return result;
+    }
+    /** Attach a minimal session emission when a compact/light path used textResult. */
+    ensureExploreEmission(result, projectRoot, query) {
+        if (result[explore_session_state_1.EXPLORE_EMISSION_KEY]) {
+            const em = result[explore_session_state_1.EXPLORE_EMISSION_KEY];
+            if (em.partial === undefined || !em.nextAnchor) {
+                const meta = (0, explore_repeat_guard_1.inferExplorePartialMeta)(result.content?.[0]?.text ?? '');
+                if (em.partial === undefined)
+                    em.partial = meta.partial;
+                if (!em.nextAnchor && meta.nextAnchor)
+                    em.nextAnchor = meta.nextAnchor;
+            }
+            return result;
+        }
+        const text = result.content?.[0]?.text ?? '';
+        const meta = (0, explore_repeat_guard_1.inferExplorePartialMeta)(text);
+        result[explore_session_state_1.EXPLORE_EMISSION_KEY] = {
+            projectRoot,
+            query,
+            files: [],
+            sourceBytes: 0,
+            responseBytes: text.length,
+            partial: meta.partial,
+            nextAnchor: meta.nextAnchor,
+        };
         return result;
     }
     /**
@@ -9013,6 +11376,10 @@ class ToolHandler {
                 lines.push(`- ${p.path} (edited ${ageMs}ms ago, ${label})`);
             }
         }
+        const updateNotice = (0, update_check_1.getUpdateNotice)();
+        if (updateNotice) {
+            lines.push('', '**Update available:**', updateNotice);
+        }
         return this.textResult(lines.join('\n'));
     }
     /**
@@ -9686,7 +12053,11 @@ class ToolHandler {
             const tail = lastQualifierPart(symbol);
             if (tail && tail !== symbol) {
                 try {
-                    pool = cg.getNodesByName(tail).filter((n) => this.matchesSymbol(n, symbol) || this.matchesSymbol(n, tail));
+                    // Qualified miss: re-probe by bare member, but ONLY keep rows that
+                    // still match the FULL qualifier. Never `matchesSymbol(n, tail)` —
+                    // that is a bare-name match and turns `Foo.init` into every `init`
+                    // in the monorepo (hundreds of definitions → token bomb).
+                    pool = cg.getNodesByName(tail).filter((n) => this.matchesSymbol(n, symbol));
                 }
                 catch {
                     pool = [];
@@ -9896,7 +12267,9 @@ class ToolHandler {
     }
     textResult(text) {
         return {
-            content: [{ type: 'text', text }],
+            // Single choke point for every tool's text, so no section builder can ship
+            // a stop-searching directive on an output that declares itself partial.
+            content: [{ type: 'text', text: reconcilePartialAnswerNow(text) }],
         };
     }
     /**