homegraph 1.6.0 → 1.6.1

package/CHANGELOG.md

@@ -10,6 +10,13 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
 
+## [1.6.1] - 2026-09-28
+
+### Improvements
+
+- MCP default tools/list is now the product slim pair — `homegraph_explore`, `homegraph_project` — so tool schemas stop dominating host context. Full catalog via `HOMEGRAPH_MCP_TOOLS=all` (or `*`) or an explicit comma list (e.g. add `arkui_migrate` when needed). MCP initialize instructions and the explore tool description match the slim surface (no pointers to tools hidden by default) (Spec 0051).
+- ArkTS explore can bundle verified render/navigation scope, used imports and types, explicit module exports and local dependency configuration with the located source. Attached SDK modules provide bounded method/parameter signatures, while control summaries distinguish icon appearance, click guards and direct enabled bindings. Whole-group budgets and source fingerprints preserve evidence boundaries; optional local pack audit supports error analysis. No additional model call or mandatory tool (Spec 0050).
+
 ## [1.6.0] - 2026-09-23
 
 ### Improvements
@@ -38,6 +45,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Improvements
 
+- ArkTS explore can retain grounded page/literal/object targets and report request evidence separately from source completeness. Verified joint targets improve candidate ordering; a scoped enabled-binding check distinguishes actual modifiers from appearance-only controls while keeping runtime behavior unverified. Results honor source fingerprints and pack budgets, with independent target/behavior switches. Existing precise relationship and resource routes remain available (Spec 0049).
 - Bump `arkanalyzer` to **1.0.94**.
 - Harmony projects with a root `build-profile.json5` now default to **serial indexing** after ArkAnalyzer: one parse worker and no resolve/synthesis worker pool. On SceneBoard-scale repos this cut peak process-tree PrivateMemory from ~8.5GB to ~3.8GB with only ~6% more wall clock. Opt out with `HOMEGRAPH_HARMONY_SERIAL=0`; force on with `=1`. Explicit `CODEGRAPH_PARSE_WORKERS` still overrides parse concurrency (Spec 0037).
 - MCP product index readiness is now five short states (`empty` / `fast` / `full` / `dirty` / `syncing`): tool replies use a one-line `HomeGraph status=…` footer (or that line alone when the tool cannot answer yet). Pending edits surface as `dirty` with path list instead of the long stale banner; write locks stay `syncing`. MCP initialize includes a one-line status glossary (Spec 0035).
@@ -274,3 +282,4 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 [1.5.8]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.5.8
 [1.5.10]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.5.10
 [1.6.0]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.0
+[1.6.1]: https://github.com/fujiaxin-coder/homegraph/releases/tag/v1.6.1

package/README.md

@@ -171,29 +171,76 @@ homegraph serve mcp             # 启动 MCP 服务（一般由 Agent 自动拉
 
 Agent 侧工具名前缀为 `homegraph_`。
 
-**暴露规则：** 默认注册全部工具。索引文件数 **少于 500** 的小项目会自动收缩为三个核心工具（`explore` / `search` / `node`）。可通过环境变量 `HOMEGRAPH_MCP_TOOLS`（逗号分隔短名，如 `explore,node`）自定义暴露列表。
+### 默认暴露（下载即用）
 
-**跨项目查询：** 所有工具均支持可选参数 `projectPath`（绝对路径），用于在 monorepo 中查询子项目，或当 MCP 服务器根目录没有索引时指定目标项目。
+未设置 `HOMEGRAPH_MCP_TOOLS` 时，`tools/list` **只注册下面 2 个工具**（为压缩宿主上下文；Spec 0051）。刚升级后若发现以前能用的 `homegraph_node` / `search` / `arkui_migrate` 等「不见了」，不是卸载坏了，而是默认不再暴露——实现仍在，按下方「如何打开更多工具」恢复即可。
+
+| 工具 | 用途 |
+|------|------|
+| `homegraph_project` | 工程/模块地图与 Harmony skeleton、资源**路径**导航（无符号正文、无调用图） |
+| `homegraph_explore` | 通用结构探索：相关符号源码、调用路径、usage/依赖/NAPI 关系、route/resource/capability 等图证据 |
 
-**图谱数据源（`--sources` / `HOMEGRAPH_SOURCES`）：** 控制 MCP 查询是否使用工程索引、OHOS SDK API 库，或两者。取值 `both`（默认）| `project` | `sdk` | `none`。CLI 优先于环境变量。评测示例：`homegraph serve mcp --path <app> --sources sdk`。`homegraph_status` 会打印当前模式。
+### 默认不暴露（需配置才进 tools/list）
+
+下列工具 **handler 仍在**，默认不出现在 `tools/list`；未配置时直接调用会返回 `disabled via HOMEGRAPH_MCP_TOOLS`。
 
 | 工具 | 用途 |
 |------|------|
-| `homegraph_usages` | **精确用法清单首选**：查询一个已命名 API、成员、常量或字段在哪里被引用 |
-| `homegraph_modules` | **模块拓扑首选**：查询已命名模块之间的依赖关系或循环依赖 |
-| `homegraph_native` | **Native 边界首选**：查询已命名路径或类型的 NAPI/native 导出和注册位置 |
-| `homegraph_explore` | **通用结构探索**：一次调用返回相关符号的源码、调用路径与影响范围；窄清单问题优先使用上面三个专用工具 |
-| `homegraph_search` | 按名称快速搜索符号（仅返回位置，不含源码） |
-| `homegraph_node` | 读取单个符号或整个文件的源码（带行号）及调用关系；可替代 Read 读文件 |
+| `homegraph_usages` | 精确用法清单：已命名 API / 成员 / 常量 / 字段的引用位置 |
+| `homegraph_modules` | 模块拓扑：已命名模块之间的依赖或循环依赖 |
+| `homegraph_native` | Native 边界：NAPI / native 导出与注册位置 |
+| `homegraph_search` | 按名称快速搜索符号（仅位置，不含源码） |
+| `homegraph_node` | 读取单个符号或整个文件的源码（带行号）及调用关系 |
 | `homegraph_callers` / `homegraph_callees` | 查看调用方 / 被调用方 |
 | `homegraph_impact` | 变更影响分析（重构前使用） |
 | `homegraph_diff_impact` | 传入 unified diff（或 hunks），返回与变更行相交的符号及调用/影响证据包（代码审查用） |
 | `homegraph_arkui_migrate` | 一次返回 ArkUI 组件迁移/状态语义快照（装饰器、状态字段、Provide/Consume 等） |
 | `homegraph_files` | 已索引的文件树（支持 glob 过滤、按语言分组） |
 | `homegraph_status` | 索引健康状态（调试用；含 WAL 大小等） |
-| `homegraph_spec_match` | 将新需求描述与 Commit4Spec 知识图谱做全文匹配，返回相似历史Spec及关联提交与代码片段 |
-| `homegraph_spec_find` | 根据文件路径反向查找关联的Spec |
-| `homegraph_spec_trace` | 根据代码符号追溯回关联的Spec |
+| `homegraph_spec_match` | 将新需求描述与 Commit4Spec 知识图谱做全文匹配 |
+| `homegraph_spec_find` | 根据文件路径反向查找关联的 Spec |
+| `homegraph_spec_trace` | 根据代码符号追溯回关联的 Spec |
+
+默认两件套下：用法/依赖/NAPI 类问题优先用 `homegraph_explore`；读已知路径用宿主 Read/Grep；ArkUI 迁移请显式打开 `arkui_migrate`（或 `all`）。
+
+### 如何打开更多 / 全部 MCP 工具
+
+在 **MCP 服务配置的 `environment` 字段**里设置（与 `HOMEGRAPH_NO_DAEMON` 同级）。这是注入给 HomeGraph MCP **进程**的环境变量；**不要**指望只在 Windows「系统属性 → 环境变量」里添加——MCP 子进程通常读不到系统/用户变量。
+
+**打开全部工具：**
+
+```json
+{
+  "mcpServers": {
+    "homegraph": {
+      "command": "homegraph",
+      "args": ["serve", "mcp"],
+      "environment": {
+        "HOMEGRAPH_NO_DAEMON": "1",
+        "HOMEGRAPH_MCP_TOOLS": "all"
+      }
+    }
+  }
+}
+```
+
+`HOMEGRAPH_MCP_TOOLS=*` 与 `all` 等价。
+
+**只打开需要的子集（更省上下文）：**
+
+```json
+"environment": {
+  "HOMEGRAPH_MCP_TOOLS": "explore,project,node,search,arkui_migrate"
+}
+```
+
+短名即可（`node` ≡ `homegraph_node`），逗号分隔。改完后**重启对应 Agent / MCP 服务**使配置生效。
+
+**小仓注意：** 仅当设为 `all` / `*` 且索引文件数 **少于 500** 时，仍可能再裁到历史 TINY 核心集（`explore` / `search` / `node` / `diff_impact` / `project`）。小仓也要 `usages` / `arkui_migrate` 等时，请用**显式逗号列表**，不要只靠 `all`。
+
+**跨项目查询：** 所有工具均支持可选参数 `projectPath`（绝对路径），用于在 monorepo 中查询子项目，或当 MCP 服务器根目录没有索引时指定目标项目。
+
+**图谱数据源（`--sources` / `HOMEGRAPH_SOURCES`）：** 控制 MCP 查询是否使用工程索引、OHOS SDK API 库，或两者。取值 `both`（默认）| `project` | `sdk` | `none`。CLI 优先于环境变量。评测示例：`homegraph serve mcp --path <app> --sources sdk`。`homegraph_status`（需先暴露该工具）会打印当前模式。
 
 ### 查询规划（实验性）
 
@@ -333,13 +380,16 @@ npm run cli
     "homegraph": {
       "type": "stdio",
       "command": "homegraph",
-      "args": ["serve", "mcp"]
+      "args": ["serve", "mcp"],
+      "environment": {
+        "HOMEGRAPH_MCP_TOOLS": "all"
+      }
     }
   }
 }
 ```
 
-Cursor 等项目级配置写入 `./.cursor/mcp.json`，格式相同。推荐使用 `homegraph install` 自动完成。
+不设 `HOMEGRAPH_MCP_TOOLS` 时默认只暴露 `explore` + `project`；需要全量或子集时按上一节「如何打开更多 / 全部 MCP 工具」配置。Cursor 等项目级配置写入 `./.cursor/mcp.json`，格式相同。推荐使用 `homegraph install` 自动完成。
 
 ---
 

package/dist/db/queries.d.ts

@@ -46,6 +46,10 @@ export declare class QueryBuilder {
     /** Attach a versioned OHOS API db for federated symbol lookup. */
     attachOhosApiDb(dbPath: string | null): void;
     getOhosApiDbPath(): string | null;
+    /** Exact imported SDK module only. No cross-module bare-name fallback.
+     * A missing/oversized/ambiguous module returns no claim of signature coverage.
+     */
+    getOhosApiModuleNodes(specifier: string): Node[];
     private hasOhosApiAttached;
     private mapOhosApiNodeRow;
     /** Set the normalized project-name tokens used to down-weight non-discriminative

package/dist/db/queries.js

@@ -247,6 +247,21 @@ class QueryBuilder {
     getOhosApiDbPath() {
         return this.ohosApiDbPath;
     }
+    /** Exact imported SDK module only. No cross-module bare-name fallback.
+     * A missing/oversized/ambiguous module returns no claim of signature coverage.
+     */
+    getOhosApiModuleNodes(specifier) {
+        if (!this.ohosApiDbPath || !/^@(ohos|hms|kit)\.[A-Za-z0-9_.]+$/.test(specifier))
+            return [];
+        const stem = specifier.startsWith('@kit.') ? specifier.slice(5) : specifier;
+        const escaped = stem.replace(/[\\%_]/g, c => `\\${c}`);
+        const rows = this.db.prepare(`SELECT * FROM ohos_api.nodes WHERE
+      file_path = ? OR file_path = ? OR file_path LIKE ? ESCAPE '\\' OR file_path LIKE ? ESCAPE '\\'
+      ORDER BY file_path, start_line LIMIT 257`).all(`${stem}.d.ts`, `${stem}.d.ets`, `%/${escaped}.d.ts`, `%/${escaped}.d.ets`);
+        if (rows.length > 256 || new Set(rows.map(row => row.file_path)).size !== 1)
+            return [];
+        return rows.map(row => this.mapOhosApiNodeRow(row));
+    }
     hasOhosApiAttached() {
         return this.ohosApiDbPath != null;
     }

package/dist/graph/evidence-paths.d.ts

@@ -53,6 +53,8 @@ export declare function isEvidencePathNode(n: Node): boolean;
 export declare function completeEvidencePathCandidates(query: string, nodes: Node[], lookup: (qualifiedName: string, limit: number) => Node[], plan?: QueryPlan): Node[];
 /** Resolve only actual candidate identities; a bare homonym never selects the first hit. */
 export declare function resolveEvidencePathGoal(query: string, nodes: Node[], focusIds: Set<string>, plan?: QueryPlan): EvidencePathGoal;
+/** Framework-labelled static UI wiring; never treat an arbitrary reference as rendering. */
+export declare function isArkuiScopeEdge(edge: Edge): boolean;
 export declare function evidenceEdgeCost(edge: Edge, goal: EvidencePathGoal): number | null;
 export declare function evidenceEdgeKey(edge: Edge): string;
 /** One bounded search per request. Each orientation follows directed edges throughout. */

package/dist/graph/evidence-paths.js

@@ -4,6 +4,7 @@ exports.EVIDENCE_PATH_LIMITS = void 0;
 exports.isEvidencePathNode = isEvidencePathNode;
 exports.completeEvidencePathCandidates = completeEvidencePathCandidates;
 exports.resolveEvidencePathGoal = resolveEvidencePathGoal;
+exports.isArkuiScopeEdge = isArkuiScopeEdge;
 exports.evidenceEdgeCost = evidenceEdgeCost;
 exports.evidenceEdgeKey = evidenceEdgeKey;
 exports.searchEvidencePaths = searchEvidencePaths;
@@ -108,11 +109,18 @@ function edgeSemantics(edge) {
         || ['callback', 'event-emitter', 'closure-collection', 'fn-pointer-dispatch', 'arkui-emitter', 'arkui-common-event', 'arkui-taskpool'].includes(String(by));
     return { state, event };
 }
+/** Framework-labelled static UI wiring; never treat an arbitrary reference as rendering. */
+function isArkuiScopeEdge(edge) {
+    const by = edge.metadata?.synthesizedBy;
+    return (edge.kind === 'references' || edge.kind === 'calls' || edge.kind === 'contains') && ((by === 'viewtree' && ['child-component', 'builder', 'builder-param'].includes(String(edge.metadata?.via)))
+        || (by === 'arkui-ownership' && edge.metadata?.via === 'build') || by === 'arkui-child' || by === 'arkui-named-nav' || by === 'arkts-route-map' || by === 'arkui-route');
+}
 function evidenceEdgeCost(edge, goal) {
     const { state, event } = edgeSemantics(edge);
     let relevanceCost;
     if (goal.kind === 'structure') {
-        if (!['extends', 'implements', 'overrides', 'instantiates'].includes(edge.kind))
+        if (!['extends', 'implements', 'overrides', 'instantiates'].includes(edge.kind)
+            && !(process.env.HOMEGRAPH_ARKTS_IMPLEMENTATION_CONTEXT !== '0' && isArkuiScopeEdge(edge)))
             return null;
         relevanceCost = 0;
     }
@@ -143,7 +151,7 @@ function searchEvidencePaths(graph, goal, options = {}) {
     const neighbors = new Map();
     const paths = [];
     const missing = [];
-    const kinds = goal.kind === 'structure' ? ['extends', 'implements', 'overrides', 'instantiates'] : ['calls', 'references'];
+    const kinds = goal.kind === 'structure' ? ['extends', 'implements', 'overrides', 'instantiates', ...(process.env.HOMEGRAPH_ARKTS_IMPLEMENTATION_CONTEXT !== '0' ? ['calls', 'references', 'contains'] : [])] : ['calls', 'references'];
     const alive = () => {
         if (now() - started >= limits.milliseconds) {
             hits.add('time');
@@ -179,7 +187,16 @@ function searchEvidencePaths(graph, goal, options = {}) {
         stats.rowsRead += rows.length;
         if (rows.length > limits.perNode)
             hits.add('neighbors');
-        const valid = rows.slice(0, limits.perNode).filter(e => evidenceEdgeCost(e, goal) !== null
+        const valid = rows.slice(0, limits.perNode).map(e => {
+            if (goal.kind === 'structure' && e.kind === 'contains' && process.env.HOMEGRAPH_ARKTS_IMPLEMENTATION_CONTEXT !== '0') {
+                const from = node(e.source);
+                const to = node(e.target);
+                if (from && ['component', 'struct'].includes(from.kind) && to?.kind === 'method' && to.name === 'build') {
+                    return { ...e, metadata: { ...e.metadata, synthesizedBy: 'arkui-ownership', via: 'build' } };
+                }
+            }
+            return e;
+        }).filter(e => evidenceEdgeCost(e, goal) !== null
             && node(e.source) && node(e.target)).sort((a, b) => evidenceEdgeCost(a, goal) - evidenceEdgeCost(b, goal)
             || evidenceEdgeKey(a).localeCompare(evidenceEdgeKey(b)));
         adjacency.set(key, valid);

package/dist/mcp/arkts-evidence-packs.d.ts

@@ -1,3 +1,6 @@
+import { type SdkModule } from './implementation-context';
+import { type RequestContract } from '../search/request-contract';
+import { type RequestEvidence, type ControlEvidence } from './request-evidence';
 import type HomeGraph from '../index';
 import type { Edge, Node } from '../types';
 import type { ExploreEmission } from './explore-session-state';
@@ -22,6 +25,15 @@ interface EvidencePack {
     sources: string[];
     priority: number;
     gaps: EvidenceGap[];
+    context?: {
+        label: string;
+        notes: string[];
+        sdk?: {
+            module: string;
+            version: string;
+            nodes: Node[];
+        };
+    };
     relation?: RelationEvidence;
     path?: {
         id: string;
@@ -36,6 +48,9 @@ export interface ArktsEvidenceResult {
         version: 1 | 2;
         scope: 'bounded_static_evidence';
         status: 'complete' | 'partial' | 'empty';
+        requestEvidence?: RequestEvidence;
+        controls?: ControlEvidence[];
+        implementationContext?: Array<NonNullable<EvidencePack['context']>>;
         selectedPacks: string[];
         gaps: EvidenceGap[];
         relations: NonNullable<EvidencePack['relation']>[];
@@ -62,6 +77,8 @@ export declare function buildArktsEvidencePacks(graph: Pick<HomeGraph, 'getNode'
     maxChars: number;
     maxFiles?: number;
     pathSearch?: EvidencePathSearch;
+    requestContract?: RequestContract;
+    sdkModule?: (module: string) => SdkModule | undefined;
 }): ArktsEvidenceResult | null;
 export {};
 //# sourceMappingURL=arkts-evidence-packs.d.ts.map

package/dist/mcp/arkts-evidence-packs.js

@@ -1,6 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildArktsEvidencePacks = buildArktsEvidencePacks;
+const arkts_1 = require("../extraction/languages/arkts");
+const implementation_context_1 = require("./implementation-context");
+const path = __importStar(require("node:path"));
+const request_contract_1 = require("../search/request-contract");
+const request_evidence_1 = require("./request-evidence");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const utils_1 = require("../utils");
@@ -8,7 +46,7 @@ const evidence_rendering_1 = require("./evidence-rendering");
 const explore_dedup_1 = require("./explore-dedup");
 const evidence_paths_1 = require("../graph/evidence-paths");
 const LIMITS = { nodes: 36, expand: 12, edges: 48, files: 8, fileBytes: 512 * 1024, bytes: 2 * 1024 * 1024 };
-const DECLARATIONS = new Set(['class', 'struct', 'component', 'interface', 'method', 'function', 'property', 'field', 'constant', 'variable', 'enum']);
+const BASE_DECLARATIONS = new Set(['class', 'struct', 'component', 'interface', 'method', 'function', 'property', 'field', 'constant', 'variable', 'enum']);
 const CONTAINERS = new Set(['class', 'struct', 'component', 'interface', 'enum']);
 const RELATIONS = new Set(['calls', 'references', 'extends', 'implements', 'instantiates']);
 const inline = (s) => s.replace(/[`\r\n]/g, ' ');
@@ -22,16 +60,32 @@ const artifact = (n) => n.filePath.includes('@dummy') || n.name.startsWith('@dum
     || (n.name === 'constructor' && n.startLine === 1 && n.endLine === 1);
 /** Consume already-located nodes. No text search, new planner call or recursive retrieval. */
 function buildArktsEvidencePacks(graph, options) {
+    const contextEnabled = (0, implementation_context_1.implementationContextEnabled)();
+    const DECLARATIONS = contextEnabled ? new Set([...BASE_DECLARATIONS, 'type_alias', 'import', 'export', 'route', 'file']) : BASE_DECLARATIONS;
     if (!options.nodes.some(n => local(n) && /\.ets$/i.test(n.filePath) && DECLARATIONS.has(n.kind)))
         return null;
     const search = options.pathSearch;
+    const targetChecks = (0, request_contract_1.accuracyTargetsEnabled)();
+    const behaviorChecks = (0, request_contract_1.accuracyCoverageEnabled)();
+    const inspector = options.requestContract && (targetChecks || behaviorChecks)
+        ? (0, request_evidence_1.createRequestEvidenceInspector)(options.requestContract) : undefined;
+    const requestSources = new Map();
+    const requestUnit = (s) => {
+        let unit = requestSources.get(s);
+        if (!unit) {
+            unit = { filePath: s.node.filePath, start: s.start, source: s.source };
+            requestSources.set(s, unit);
+        }
+        return unit;
+    };
     const requiredIds = search ? new Set([...search.goal.anchorIds, ...search.paths.flatMap(p => p.nodeIds)]) : options.focusIds;
     const inputNodes = search && requiredIds.size ? [...requiredIds].flatMap(id => { const n = graph.getNode(id); return n ? [n] : []; }) : options.nodes;
     const all = (0, evidence_rendering_1.canonicalSourceDeclarations)(inputNodes.filter(n => DECLARATIONS.has(n.kind) && local(n) && !artifact(n)));
     if (!all.length)
         return null;
+    const inputOrder = new Map(all.map((node, index) => [node.id, index]));
     const candidates = all.sort((a, b) => Number(requiredIds.has(b.id)) - Number(requiredIds.has(a.id))
-        || a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine).slice(0, LIMITS.nodes);
+        || (inspector && targetChecks ? inputOrder.get(a.id) - inputOrder.get(b.id) : a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine)).slice(0, LIMITS.nodes);
     const focus = candidates.filter(n => requiredIds.has(n.id));
     // A named owning type provides scope for its named members, not another
     // callable endpoint. Do not invent a missing Type→method call obligation.
@@ -46,11 +100,11 @@ function buildArktsEvidencePacks(graph, options) {
     let bytesRead = 0;
     const root = (0, node_fs_1.realpathSync)(options.projectRoot);
     const maxFiles = Math.max(1, Math.min(LIMITS.files, options.maxFiles ?? LIMITS.files));
-    const readSource = (node) => {
+    const readSource = (node, snapshot = false) => {
         const previous = nodeSources.get(node.id);
         if (previous)
             return previous;
-        if (!local(node) || artifact(node) || !DECLARATIONS.has(node.kind)) {
+        if ((!local(node) && !(contextEnabled && (snapshot || node.kind === 'route' || (!node.filePath.startsWith('ohos-sdk:') && /\.d\.(?:ts|ets)$/.test(node.filePath))))) || artifact(node) || !DECLARATIONS.has(node.kind)) {
             const failure = { gap: { target: label(node), reason: 'unavailable', nextAnchor: location(node) } };
             nodeSources.set(node.id, failure);
             return failure;
@@ -90,7 +144,7 @@ function buildArktsEvidencePacks(graph, options) {
                         const content = buffer.subarray(0, bytes).toString('utf8');
                         const indexed = graph.getFile(node.filePath);
                         // Hash equality, not mtime: edits can retain timestamps and invalidate ranges.
-                        if (bytes !== size || !indexed || indexed.contentHash !== (0, node_crypto_1.createHash)('sha256').update(content).digest('hex'))
+                        if (bytes !== size || (!snapshot && (!indexed || indexed.contentHash !== (0, node_crypto_1.createHash)('sha256').update(content).digest('hex'))))
                             file.reason = 'stale';
                         else
                             file = { content, lines: content.split('\n'), fingerprint: (0, explore_dedup_1.fileFingerprint)(content) };
@@ -102,6 +156,14 @@ function buildArktsEvidencePacks(graph, options) {
             }
             fileCache.set(node.filePath, file);
         }
+        if ((snapshot || node.kind === 'file') && file.lines)
+            node = { ...node, endLine: file.lines.length };
+        if (node.kind === 'import' && file.lines) {
+            const head = file.lines.slice(node.startLine - 1, node.startLine + 20).join('\n');
+            const importText = head.match(/^\s*import\s+[\s\S]*?\bfrom\s*['"][^'"\r\n]+['"][^\S\r\n]*;?/);
+            if (importText)
+                node = { ...node, endLine: node.startLine + importText[0].split('\n').length - 1 };
+        }
         const reason = file.reason ?? (!Number.isInteger(node.startLine) || !Number.isInteger(node.endLine)
             || node.startLine < 1 || node.endLine < node.startLine || node.endLine > file.lines.length
             || !file.lines.slice(node.startLine - 1, node.endLine).join('\n').trim() ? 'invalid_range' : undefined);
@@ -117,13 +179,13 @@ function buildArktsEvidencePacks(graph, options) {
         const id = `${node.filePath}:${start}-${node.endLine}`;
         if (!sources.has(id))
             sources.set(id, { id, node, start, end: node.endLine,
-                source: file.lines.slice(start - 1, node.endLine).join('\n'), fingerprint: file.fingerprint });
+                source: file.lines.slice(start - 1, node.endLine).join('\n'), fingerprint: file.fingerprint, ...(snapshot ? { snapshot: true } : {}) });
         const result = { id };
         nodeSources.set(node.id, result);
         return result;
     };
     const dependencies = (nodes) => {
-        const resolved = nodes.map(readSource);
+        const resolved = nodes.map(n => readSource(n));
         return { sources: [...new Set(resolved.flatMap(s => s.id ? [s.id] : []))],
             gaps: resolved.flatMap(s => s.gap ? [s.gap] : []) };
     };
@@ -134,6 +196,104 @@ function buildArktsEvidencePacks(graph, options) {
     if (all.length > candidates.length)
         globalGaps.push({ target: `${all.length - candidates.length} additional candidates`,
             reason: 'scope_limit', nextAnchor: location(all[candidates.length]) });
+    const configNode = (file) => ({ id: `context-config:${file}`, kind: 'constant', name: file, qualifiedName: file,
+        filePath: file, startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: 0, language: 'yaml' });
+    const manifestCache = new Map();
+    const nearestManifest = (file) => {
+        if (manifestCache.has(file))
+            return manifestCache.get(file);
+        let dir = path.posix.dirname(file.replace(/\\/g, '/'));
+        let found;
+        for (let depth = 0; depth < 12; depth++) {
+            const manifest = path.posix.join(dir, 'oh-package.json5');
+            const absolute = (0, utils_1.validatePathWithinRoot)(root, manifest);
+            try {
+                if (absolute && (0, node_fs_1.statSync)(absolute).isFile()) {
+                    found = configNode(manifest);
+                    break;
+                }
+            }
+            catch { /* absent */ }
+            if (dir === '.')
+                break;
+            dir = path.posix.dirname(dir);
+        }
+        manifestCache.set(file, found);
+        return found;
+    };
+    const configValue = (node) => {
+        const r = readSource(node, true);
+        if (!r.id)
+            return undefined;
+        try {
+            const value = (0, arkts_1.parseJson5Minimal)(sources.get(r.id).source);
+            return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const moduleBinding = (importer, module) => {
+        const manifest = nearestManifest(importer);
+        if (!manifest)
+            return undefined;
+        const config = configValue(manifest);
+        const deps = config?.dependencies;
+        if (!deps || typeof deps !== 'object' || Array.isArray(deps))
+            return undefined;
+        const dep = deps[module];
+        if (typeof dep !== 'string' || !/^file:\.{1,2}\//.test(dep))
+            return undefined;
+        const depRoot = path.posix.normalize(path.posix.join(path.posix.dirname(manifest.filePath), dep.slice(5)));
+        if (depRoot === '..' || depRoot.startsWith('../') || path.posix.isAbsolute(depRoot))
+            return undefined;
+        const targetManifest = configNode(path.posix.join(depRoot, 'oh-package.json5'));
+        const target = configValue(targetManifest);
+        if (!target)
+            return undefined;
+        const entry = typeof target.main === 'string' ? path.posix.join(depRoot, target.main) : depRoot;
+        const relativePath = './' + path.posix.relative(path.posix.dirname(importer), entry);
+        return { relativePath, witnesses: [manifest, targetManifest] };
+    };
+    const contextGroups = contextEnabled ? (0, implementation_context_1.collectImplementationContext)(graph, focus.length ? focus : candidates, node => { const r = readSource(node); return r.id ? sources.get(r.id)?.source : undefined; }, options.sdkModule, moduleBinding) : [];
+    for (const group of contextGroups) {
+        const deps = dependencies(group.nodes);
+        packs.push({ id: group.id, label: group.label, priority: 130, ...deps,
+            context: { label: group.label, notes: [...group.notes, ...group.missing.map(m => `Unresolved: ${m}`)], ...(group.sdk ? { sdk: group.sdk } : {}) } });
+        for (const missing of group.missing)
+            globalGaps.push({ target: missing, reason: 'unindexed_connection', nextAnchor: missing });
+    }
+    // Only ancestor manifests of the located code; no workspace traversal or credential files.
+    const configs = new Set();
+    for (const node of contextEnabled && contextGroups.some(g => g.id.startsWith('impl-import:')) ? (focus.length ? focus : candidates).slice(0, 3) : []) {
+        let dir = path.posix.dirname(node.filePath.replace(/\\/g, '/'));
+        for (let depth = 0; depth < 12; depth++) {
+            const manifest = path.posix.join(dir, 'oh-package.json5');
+            const absolute = (0, utils_1.validatePathWithinRoot)(root, manifest);
+            try {
+                if (absolute && (0, node_fs_1.statSync)(absolute).isFile()) {
+                    configs.add(manifest);
+                    break;
+                }
+            }
+            catch { /* missing ancestor manifest */ }
+            if (dir === '.')
+                break;
+            dir = path.posix.dirname(dir);
+        }
+    }
+    if (configs.size)
+        configs.add('build-profile.json5');
+    for (const config of configs) {
+        const node = { id: `context-config:${config}`, kind: 'constant', name: config, qualifiedName: config,
+            filePath: config, startLine: 1, endLine: 1, startColumn: 0, endColumn: 0, updatedAt: Date.now(), language: 'yaml' };
+        const dep = readSource(node, true);
+        if (dep.id)
+            packs.push({ id: node.id, label: `module/version configuration ${config}`, priority: 125, sources: [dep.id], gaps: [],
+                context: { label: `module/version configuration ${config}`, notes: ['Current configuration snapshot; declared dependencies do not prove installation or export availability.'] } });
+        else if (dep.gap && dep.gap.reason !== 'unavailable')
+            globalGaps.push(dep.gap);
+    }
     const candidateIds = new Set(candidates.map(n => n.id));
     const edges = [];
     const edgeKeys = new Set();
@@ -158,6 +318,16 @@ function buildArktsEvidencePacks(graph, options) {
             edges.push(edge);
         }
     }
+    for (const group of contextGroups)
+        for (const edge of group.edges) {
+            if (edge.kind === 'imports')
+                continue;
+            const key = (0, evidence_paths_1.evidenceEdgeKey)(edge);
+            if (!edgeKeys.has(key)) {
+                edgeKeys.add(key);
+                edges.push(edge);
+            }
+        }
     if (search) {
         const fallbackNeighbors = search.missing.length || search.goal.anchorIds.length < 2 ? search.neighbors : [];
         for (const edge of [...search.paths.flatMap(p => p.edges), ...fallbackNeighbors]) {
@@ -194,7 +364,7 @@ function buildArktsEvidencePacks(graph, options) {
     for (const [i, edge] of edges.entries()) {
         const from = graph.getNode(edge.source);
         const to = graph.getNode(edge.target);
-        if (!from || !to || !local(from) || !local(to)) {
+        if (!from || !to || (!local(from) && from.kind !== 'route') || (!local(to) && to.kind !== 'route')) {
             globalGaps.push({ target: `${from ? label(from) : edge.source} ${edge.kind} ${to ? label(to) : edge.target}`,
                 reason: 'unavailable', nextAnchor: from ? location(from) : edge.source });
             continue;
@@ -267,6 +437,19 @@ function buildArktsEvidencePacks(graph, options) {
             globalGaps.push({ target: `connecting path in the bounded graph slice: ${label(relationFocus[0])} → ${label(disconnected[0])}`,
                 reason: 'unindexed_connection', nextAnchor: location(disconnected[0]) });
     }
+    // Rank already-read, hash-verified declarations by joint targets in the same file.
+    // Never discard a dependent helper merely because it has no UI label.
+    if (inspector && targetChecks) {
+        const byFile = new Map();
+        for (const unit of sources.values()) {
+            const list = byFile.get(unit.node.filePath) ?? [];
+            list.push(requestUnit(unit));
+            byFile.set(unit.node.filePath, list);
+        }
+        const scores = new Map([...byFile].map(([file, units]) => [file, inspector.score(units)]));
+        for (const pack of packs)
+            pack.priority += 30 * Math.max(0, ...pack.sources.map(id => scores.get(sources.get(id).node.filePath) ?? 0));
+    }
     const selected = [];
     const rejectedGap = (p) => p.gaps.length ? p.gaps : [{ target: p.label, reason: 'budget',
             nextAnchor: sources.get(p.sources[0] ?? '') ? location(sources.get(p.sources[0]).node) : p.label }];
@@ -281,6 +464,12 @@ function buildArktsEvidencePacks(graph, options) {
         return units.filter(s => !units.some(other => other.id !== s.id && other.node.filePath === s.node.filePath
             && other.start <= s.start && other.end >= s.end)).sort((a, b) => a.node.filePath.localeCompare(b.node.filePath) || a.start - b.start);
     };
+    const controlCache = new Map();
+    const controlsFor = (chosen) => unitsFor(chosen).flatMap(unit => {
+        if (!controlCache.has(unit))
+            controlCache.set(unit, (0, request_evidence_1.inspectControlEvidence)([requestUnit(unit)]));
+        return controlCache.get(unit);
+    }).slice(0, 8);
     const relationsFor = (chosen) => [...new Map(chosen.flatMap(p => p.path?.relations ?? (p.relation ? [p.relation] : []))
             .map(r => [JSON.stringify(r), r])).values()];
     const stopFor = (chosen) => search?.stopReason === 'supported'
@@ -291,6 +480,16 @@ function buildArktsEvidencePacks(graph, options) {
             'Complete declarations preserve internal branches. Enclosing callers and runtime order/value flow are not proven. Retrieval is not task completion.'];
         if (search)
             lines.push(`Path goal: ${search.goal.kind}; search direction: ${search.goal.direction}; stop: ${stopFor(chosen)}. Static paths do not prove runtime behavior.`);
+        if (inspector)
+            lines.push(...(0, request_evidence_1.renderRequestEvidence)(inspector.inspect(unitsFor(chosen).map(requestUnit)), targetChecks, behaviorChecks));
+        if ((0, implementation_context_1.controlEvidenceEnabled)())
+            lines.push(...(0, request_evidence_1.renderControlEvidence)(controlsFor(chosen)));
+        for (const pack of chosen.filter(p => p.context)) {
+            lines.push(`**Implementation context: ${inline(pack.context.label)}**`, ...pack.context.notes.map(n => `- ${inline(n)}`));
+            const sdk = pack.context.sdk;
+            if (sdk)
+                lines.push(`Indexed SDK signatures for ${inline(sdk.module)}; database version ${inline(sdk.version)}. Not source bodies or device validation.`, ...sdk.nodes.map(n => `- ${inline(n.filePath)}:${n.startLine} ${inline(n.signature || n.name)}${n.docstring ? ` — ${inline(n.docstring).slice(0, 500)}${n.docstring.length > 500 ? ' [documentation excerpt; remaining constraints not shown]' : ''}` : ''}`));
+        }
         const chosenPaths = chosen.filter(p => p.path);
         if (chosenPaths.length)
             lines.push('**Directed paths (all source dependencies provided)**', ...chosenPaths.map(p => `- ${inline(p.label)}`));
@@ -304,7 +503,7 @@ function buildArktsEvidencePacks(graph, options) {
         for (const unit of unitsFor(chosen)) {
             // Fence longer than any source backtick run: source-like guidance cannot escape.
             const fence = '`'.repeat(Math.max(3, ...Array.from(unit.source.matchAll(/`+/g), m => m[0].length + 1)));
-            lines.push(`### ${inline(unit.node.filePath)}:${unit.start}-${unit.end} — complete declaration; file-fingerprint=${unit.fingerprint}`, fence + unit.node.language, unit.source.split('\n').map((line, i) => `${unit.start + i}\t${line}`).join('\n'), fence);
+            lines.push(`### ${inline(unit.node.filePath)}:${unit.start}-${unit.end} — ${unit.snapshot ? 'current configuration snapshot' : unit.node.kind === 'file' ? 'complete indexed file' : 'complete declaration'}; file-fingerprint=${unit.fingerprint}`, fence + unit.node.language, unit.source.split('\n').map((line, i) => `${unit.start + i}\t${line}`).join('\n'), fence);
         }
         if (gaps.length) {
             lines.push('**Gaps — inspect only the missing evidence needed for the task**', ...gaps.slice(0, 6).map(g => `- ${g.reason}: ${inline(g.target)}. Next anchor: ${inline(g.nextAnchor)}.`));
@@ -341,11 +540,20 @@ function buildArktsEvidencePacks(graph, options) {
     const locatedNodes = candidates.filter(n => units.some(s => s.node.filePath === n.filePath && s.start <= n.startLine && s.end >= n.endLine))
         .map(n => ({ id: n.id, name: n.name, qualifiedName: n.qualifiedName, filePath: n.filePath, startLine: n.startLine }));
     const status = !units.length ? 'empty' : gaps.length ? 'partial' : 'complete';
+    const checkedRequest = inspector?.inspect(units.map(requestUnit));
+    const requestEvidence = checkedRequest ? { ...checkedRequest, targets: targetChecks ? checkedRequest.targets : [],
+        behaviors: behaviorChecks ? checkedRequest.behaviors : [] } : undefined;
     return { text, emission: { projectRoot: options.projectRoot, query: options.query, files,
             sourceBytes: files.reduce((sum, f) => sum + f.bytes, 0), responseBytes: text.length, locatedNodes,
             evidenceStatus: status, partial: status !== 'complete', coveredObligations: selected.map(p => p.label),
             uncoveredObligations: gaps.map(g => `${g.reason}: ${g.target}`), nextAnchor: gaps[0]?.nextAnchor },
-        metadata: { version: search ? 2 : 1, scope: 'bounded_static_evidence', status, selectedPacks: selected.map(p => p.id), gaps,
+        metadata: { ...((0, implementation_context_1.controlEvidenceEnabled)() ? { controls: controlsFor(selected) } : {}),
+            ...(contextEnabled ? { implementationContext: selected.flatMap(p => p.context ? [{ ...p.context,
+                        ...(p.context.sdk ? { sdk: { ...p.context.sdk, nodes: p.context.sdk.nodes.map(n => ({
+                                    id: n.id, name: n.name, qualifiedName: n.qualifiedName, kind: n.kind, filePath: n.filePath,
+                                    startLine: n.startLine, endLine: n.endLine, startColumn: n.startColumn, endColumn: n.endColumn,
+                                    language: n.language, updatedAt: n.updatedAt, signature: n.signature,
+                                })) } } : {}) }] : []) } : {}), ...(requestEvidence ? { requestEvidence } : {}), version: search ? 2 : 1, scope: 'bounded_static_evidence', status, selectedPacks: selected.map(p => p.id), gaps,
             relations: relationsFor(selected), ...(search ? { pathSearch: { goal: search.goal, stopReason: stopFor(selected),
                     limitsHit: search.limitsHit, stats: search.stats, paths: search.paths.map(p => ({ id: p.id, nodeIds: p.nodeIds, cost: p.cost,
                         evidence: selected.some(c => c.path?.id === p.id) ? 'provided' : 'partial' })) } } : {}) } };

package/dist/mcp/evidence-audit.d.ts

@@ -0,0 +1,3 @@
+/** Opt-in local evidence only, never an answer cache. Logging cannot break retrieval. */
+export declare function recordEvidencePack(projectRoot: string, input: unknown, output: unknown): 'written' | 'disabled' | 'limit' | 'unavailable';
+//# sourceMappingURL=evidence-audit.d.ts.map