homegraph 1.5.10 → 1.6.1

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, ' ');
@@ -18,19 +56,36 @@ const local = (n) => !n.filePath.startsWith('ohos-sdk:') && !/\.d\.(?:ts|ets)$/i
 // ArkAnalyzer's virtual entry/implicit constructor has no declaration on disk.
 // Explicit constructors with a real range remain available through the normal renderer.
 const artifact = (n) => n.filePath.includes('@dummy') || n.name.startsWith('@dummy')
+    || /^%AM\d+/i.test(n.name)
     || (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.
@@ -45,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;
@@ -89,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) };
@@ -101,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);
@@ -116,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] : []) };
     };
@@ -133,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();
@@ -157,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]) {
@@ -193,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;
@@ -266,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 }];
@@ -280,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'
@@ -290,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)}`));
@@ -303,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)}.`));
@@ -340,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/daemon.d.ts

@@ -20,9 +20,12 @@
  *     so a SIGKILL'd host still reaps its proxy promptly; the proxy's socket
  *     close then decrements the daemon's refcount.
  *   - When the last client disconnects the daemon lingers for
- *     `HOMEGRAPH_DAEMON_IDLE_TIMEOUT_MS` (default 300s) so back-to-back agent
- *     runs in the same project don't repay startup, then exits cleanly. This is
- *     what keeps a single-agent session from leaking a daemon forever (#277).
+ *     `HOMEGRAPH_DAEMON_IDLE_TIMEOUT_MS` (default **60s**, Spec 0047) so a
+ *     quick reconnect does not repay startup — but **only after** any in-flight
+ *     auto-init/full index finishes (`building_fast` / `indexing`). While a
+ *     client is connected (refcount > 0) the daemon never idle-exits. This is
+ *     what keeps a single-agent session from leaking a daemon forever (#277)
+ *     without killing a half-built graph when the IDE just closed.
  *
  * What this file owns:
  *   - Listening on the daemon socket and spawning per-connection sessions.
@@ -41,6 +44,21 @@
  */
 import * as net from 'net';
 import { DaemonLockInfo } from './daemon-paths';
+/**
+ * Spec 0047: phases that block daemon idle-exit when clients=0.
+ * Routine watch/sync is NOT included.
+ */
+export declare function isBuildPhaseBlockingIdle(phase: string | null | undefined): boolean;
+/**
+ * Decide idle-timer action when the linger timer fires (refcount already 0).
+ * Pure helper for unit tests.
+ */
+export declare function decideIdleExitAction(opts: {
+    clientCount: number;
+    buildBlocking: boolean;
+}): 'exit' | 'rearm-idle' | 'poll-build';
+/** Default idle linger after last client (exported for tests). */
+export declare function defaultDaemonIdleTimeoutMs(): number;
 /**
  * Finalize daemon shutdown. On POSIX, exit immediately — it's clean and fast.
  * On Windows, do NOT force an exit while watchers may still be closing (that

package/dist/mcp/daemon.js

@@ -21,9 +21,12 @@
  *     so a SIGKILL'd host still reaps its proxy promptly; the proxy's socket
  *     close then decrements the daemon's refcount.
  *   - When the last client disconnects the daemon lingers for
- *     `HOMEGRAPH_DAEMON_IDLE_TIMEOUT_MS` (default 300s) so back-to-back agent
- *     runs in the same project don't repay startup, then exits cleanly. This is
- *     what keeps a single-agent session from leaking a daemon forever (#277).
+ *     `HOMEGRAPH_DAEMON_IDLE_TIMEOUT_MS` (default **60s**, Spec 0047) so a
+ *     quick reconnect does not repay startup — but **only after** any in-flight
+ *     auto-init/full index finishes (`building_fast` / `indexing`). While a
+ *     client is connected (refcount > 0) the daemon never idle-exits. This is
+ *     what keeps a single-agent session from leaking a daemon forever (#277)
+ *     without killing a half-built graph when the IDE just closed.
  *
  * What this file owns:
  *   - Listening on the daemon socket and spawning per-connection sessions.
@@ -75,6 +78,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_HELLO_LINE_BYTES = exports.Daemon = void 0;
+exports.isBuildPhaseBlockingIdle = isBuildPhaseBlockingIdle;
+exports.decideIdleExitAction = decideIdleExitAction;
+exports.defaultDaemonIdleTimeoutMs = defaultDaemonIdleTimeoutMs;
 exports.finalizeDaemonExit = finalizeDaemonExit;
 exports.tryAcquireDaemonLock = tryAcquireDaemonLock;
 exports.acquireLockViaExclusiveOpen = acquireLockViaExclusiveOpen;
@@ -92,8 +98,32 @@ const transport_1 = require("./transport");
 const daemon_paths_1 = require("./daemon-paths");
 const version_1 = require("./version");
 const daemon_registry_1 = require("./daemon-registry");
-/** Default idle linger after the last client disconnects. */
-const DEFAULT_IDLE_TIMEOUT_MS = 300_000;
+/** How often to re-check build phase while deferring idle exit (Spec 0047). */
+const BUILD_IDLE_POLL_MS = 2_000;
+/** Default idle linger after the last client disconnects (Spec 0047: 60s). */
+const DEFAULT_IDLE_TIMEOUT_MS = 60_000;
+/**
+ * Spec 0047: phases that block daemon idle-exit when clients=0.
+ * Routine watch/sync is NOT included.
+ */
+function isBuildPhaseBlockingIdle(phase) {
+    return phase === 'building_fast' || phase === 'indexing';
+}
+/**
+ * Decide idle-timer action when the linger timer fires (refcount already 0).
+ * Pure helper for unit tests.
+ */
+function decideIdleExitAction(opts) {
+    if (opts.clientCount > 0)
+        return 'rearm-idle';
+    if (opts.buildBlocking)
+        return 'poll-build';
+    return 'exit';
+}
+/** Default idle linger after last client (exported for tests). */
+function defaultDaemonIdleTimeoutMs() {
+    return DEFAULT_IDLE_TIMEOUT_MS;
+}
 /**
  * Hard ceiling on how long the daemon stays up with clients connected but no
  * inbound traffic. A backstop (#692): if a client's socket-close is never
@@ -372,15 +402,39 @@ class Daemon {
             return;
         if (this.idleTimeoutMs <= 0)
             return; // 0 = never idle-exit
+        // Spec 0047: if the last window closed mid-index, wait for build to finish
+        // before starting the idle linger — never exit while clients>0 either.
+        if (this.clients.size === 0 && this.engine.isIndexBuildInProgress()) {
+            this.idleTimer = setTimeout(() => {
+                this.idleTimer = null;
+                if (this.clients.size > 0)
+                    return; // reconnect disarmed the need
+                if (this.engine.isIndexBuildInProgress()) {
+                    this.armIdleTimer(); // keep polling until build settles
+                    return;
+                }
+                this.armIdleTimer(); // build done → arm full idle linger
+            }, BUILD_IDLE_POLL_MS);
+            this.idleTimer.unref?.();
+            return;
+        }
         this.idleTimer = setTimeout(() => {
             this.idleTimer = null;
             // Last-second sanity check: if a connection landed between the timer
             // firing and now, don't exit. (setImmediate-ordering is the only way
             // this races; cheap to defend against.)
-            if (this.clients.size > 0) {
+            const action = decideIdleExitAction({
+                clientCount: this.clients.size,
+                buildBlocking: this.engine.isIndexBuildInProgress(),
+            });
+            if (action === 'rearm-idle') {
                 this.armIdleTimer();
                 return;
             }
+            if (action === 'poll-build') {
+                this.armIdleTimer(); // switches to build-poll branch above
+                return;
+            }
             void this.stop('idle timeout');
         }, this.idleTimeoutMs);
         // Don't keep the event loop alive just for this — the net.Server keeps the

package/dist/mcp/engine.d.ts

@@ -48,6 +48,13 @@ export declare class MCPEngine {
     private opts;
     private closed;
     private queryPool;
+    /**
+     * Spec 0049: auto-init deferred because the root was empty. Probe until
+     * indexable, then run the normal create-DB path once.
+     */
+    private deferredAutoInitRoot;
+    private deferProbeTimer;
+    private deferAutoInitPromise;
     constructor(opts?: MCPEngineOptions);
     /**
      * Start the worker-thread query pool once a default project is open (daemon
@@ -67,8 +74,21 @@ export declare class MCPEngine {
     getProjectPath(): string | null;
     /** Shared ToolHandler — sessions delegate tool dispatch through this. */
     getToolHandler(): ToolHandler;
+    /**
+     * Spec 0047: true while auto-init / full symbol build is in flight.
+     * Used by the daemon idle timer — never idle-exit mid-build when clients=0.
+     * Does not include routine watch/sync increments.
+     */
+    isIndexBuildInProgress(): boolean;
     /** Whether the default project's HomeGraph is open. */
     hasDefaultHomeGraph(): boolean;
+    /** Spec 0049: true while auto-init is waiting for an empty root to grow sources. */
+    isAutoInitDeferred(): boolean;
+    /**
+     * Spec 0049: on tool call (or timer), re-check the deferred root and start
+     * the normal auto-init once it becomes indexable. Idempotent.
+     */
+    kickDeferredAutoInit(): Promise<boolean>;
     /**
      * Walk up from `searchFrom` to find the nearest `.homegraph/` and open it.
      * Idempotent: concurrent callers share one in-flight init; subsequent
@@ -100,6 +120,11 @@ export declare class MCPEngine {
      * @returns true if the engine is fully wired to a new (or racing) index
      */
     private tryAutoInit;
+    /** Spec 0049: create DB + fast map + background full (shared by first hit and kick). */
+    private runAutoInitCreate;
+    /** Spec 0049: remember empty root and (optionally) poll until indexable. */
+    private armDeferProbe;
+    private clearDeferProbe;
     /**
      * Open an index another process just created (Spec 0032 cold-start race).
      * Brief retries cover the window between mkdir and db file create.
@@ -143,6 +168,7 @@ export declare class MCPEngine {
  * Range: 1s … 30min. Used by product hosts (e.g. DevEco Code = 5 minutes).
  */
 export declare function parseFixedWindowEnv(raw: string | undefined): number | undefined;
+export { isIndexableRoot, parseDeferProbeMs } from './indexable-root';
 /**
  * Parse and clamp the HOMEGRAPH_WATCH_DEBOUNCE_MS env override.
  *