gitnexus 1.6.11-rc.2 → 1.6.11-rc.21

package/dist/mcp/local/local-backend.js

@@ -8,6 +8,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { createHash } from 'crypto';
+import { scoreImpactRisk, unusedAxesForImpactWalk } from '../../_shared/index.js';
 import { initLbug, executeQuery, executeParameterized, ensureVectorExtension, closeLbug, isLbugReady, statDbIdentity, dbIdentityChanged, } from '../../core/lbug/pool-adapter.js';
 import { queryClassBeanMetadata } from './bean-metadata.js';
 import { querySpringAopMetadata } from './aop-metadata.js';
@@ -23,7 +24,7 @@ import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/l
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
-import { parseDiffHunks, coalesceHunksByPath, hunksOverlapRange, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
+import { parseDiffHunks, coalesceHunksByPath, hunksOverlapRange, findGitRootByDotGit, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
 import { realpathSync } from 'fs';
 import { listRegisteredRepos, cleanupOldKuzuFiles, canonicalizePath, getStoragePaths, loadMeta, RegistryAmbiguousTargetError, } from '../../storage/repo-manager.js';
 import { GroupService, } from '../../core/group/service.js';
@@ -1178,23 +1179,56 @@ export class LocalBackend {
      * - If only 1 repo, use it
      * - If 0 or multiple without param, throw with helpful message
      *
-     * On a miss, re-reads the registry once in case a new repo was indexed
-     * while the MCP server was running.
+     * Re-reads the registry before an omitted implicit target or after an
+     * explicit miss, so long-running servers see newly indexed repositories.
      */
     async resolveRepo(repoParam, branch) {
-        let refreshedAfterAmbiguity = false;
+        return this.selectToolRepository(repoParam, branch);
+    }
+    /**
+     * Internal resolver variant for CLI/MCP tool routing and discovery.
+     * - If repoParam is given, match by name or path
+     * - If only 1 repo, use it
+     * - If multiple repos exist and repoParam is omitted, callers may opt in to
+     *   the registered repo containing process.cwd()
+     * - If 0 repos exist, or cwd cannot disambiguate multiple repos, throw
+     *
+     * Omitted-repo resolution re-reads the registry before accepting any
+     * implicit target, including a cached singleton. A caller that just obtained
+     * a fresh registry snapshot may disable that refresh explicitly.
+     */
+    async selectToolRepository(repoParam, branch, options = {}) {
+        const allowCwdDefault = options.allowCwdDefault === true;
+        const mayRefresh = options.refreshRegistry !== false;
+        let refreshed = false;
+        // A cached singleton is also an implicit choice: another process may have
+        // registered a second repo since init, which must not let a repo-less
+        // mutating call bypass the multi-repo ambiguity guard.
+        if (!repoParam && mayRefresh) {
+            await this.refreshRepos();
+            refreshed = true;
+        }
         let result;
         try {
-            result = this.resolveRepoFromCache(repoParam);
+            result = this.resolveRepoFromCache(repoParam, allowCwdDefault);
         }
         catch (err) {
             if (!(err instanceof RegistryAmbiguousTargetError))
                 throw err;
+            if (!mayRefresh || refreshed)
+                throw err;
             // Stale in-memory duplicate siblings can linger after unregister; refresh
             // once before re-throwing so a resolved registry can disambiguate (#1658).
             await this.refreshRepos();
-            refreshedAfterAmbiguity = true;
-            result = this.resolveRepoFromCache(repoParam);
+            refreshed = true;
+            result = this.resolveRepoFromCache(repoParam, allowCwdDefault);
+        }
+        // Explicit misses retain the existing one-refresh retry. Omitted targets
+        // already refreshed above unless a same-snapshot caller opted out.
+        if (!result && mayRefresh && !refreshed) {
+            await this.refreshRepos();
+            refreshed = true;
+            result = this.resolveRepoFromCache(repoParam, allowCwdDefault);
         }
         if (result) {
             // Issue: silent graph drift across sibling clones.
@@ -1208,15 +1242,6 @@ export class LocalBackend {
             });
             return this.applyBranchScope(result, branch);
         }
-        // Miss — refresh registry and try once more (skip if already refreshed above)
-        if (!refreshedAfterAmbiguity) {
-            await this.refreshRepos();
-        }
-        const retried = this.resolveRepoFromCache(repoParam);
-        if (retried) {
-            this.maybeWarnSiblingDrift(retried).catch(() => { });
-            return this.applyBranchScope(retried, branch);
-        }
         // Still no match — throw with helpful message
         if (this.repos.size === 0) {
             throw new Error('No indexed repositories. Run: gitnexus analyze');
@@ -1349,7 +1374,7 @@ export class LocalBackend {
      * Throws {@link RegistryAmbiguousTargetError} when `repoParam` matches
      * multiple handles by name and cwd cannot disambiguate (#1658).
      */
-    resolveRepoFromCache(repoParam) {
+    resolveRepoFromCache(repoParam, allowCwdDefault = false) {
         if (this.repos.size === 0)
             return null;
         if (repoParam) {
@@ -1378,6 +1403,9 @@ export class LocalBackend {
             if (nameMatches.length === 1)
                 return nameMatches[0];
             if (nameMatches.length > 1) {
+                // Explicit duplicate aliases retain the legacy fail-closed contract:
+                // only an exact cwd Git-root match may disambiguate them. Deepest path
+                // containment is reserved for an omitted read-only repo (#3073).
                 const cwdPick = this.pickRepoHandleForCwd(nameMatches);
                 if (cwdPick)
                     return cwdPick;
@@ -1402,26 +1430,46 @@ export class LocalBackend {
         if (this.repos.size === 1) {
             return this.repos.values().next().value;
         }
+        if (allowCwdDefault) {
+            const cwdPick = this.pickRepoHandleForCwd([...this.repos.values()], true);
+            if (cwdPick)
+                return cwdPick;
+        }
         return null; // Multiple repos, no param — ambiguous
     }
     /**
-     * Prefer the indexed repo whose path matches the git root of process.cwd().
+     * Match process.cwd() against indexed repositories.
      *
-     * In MCP stdio server mode, `process.cwd()` is the server's launch directory,
-     * not the agent client's cwd. If the server was started from an unrelated
-     * directory, `getGitRoot` returns null and duplicate-name resolution throws
-     * {@link RegistryAmbiguousTargetError} — callers should pass an absolute path.
+     * Explicit duplicate aliases use exact Git-root matching only. Omitted
+     * read-only calls opt into deepest containing-path selection. In that mode a
+     * candidate must not sit above cwd's Git root, so an unindexed nested checkout
+     * cannot fall through to an indexed ancestor. The `.git` ancestor fallback
+     * preserves that boundary when the git executable is unavailable.
      */
-    pickRepoHandleForCwd(candidates) {
-        const cwdRoot = getGitRoot(process.cwd());
-        if (!cwdRoot)
+    pickRepoHandleForCwd(candidates, allowContaining = false) {
+        const cwd = process.cwd();
+        const normalize = (value) => {
+            const canonical = canonicalizePath(value);
+            return process.platform === 'win32' ? canonical.toLowerCase() : canonical;
+        };
+        const isSameOrDescendant = (parent, child) => child === parent ||
+            child.startsWith(parent.endsWith(path.sep) ? parent : `${parent}${path.sep}`);
+        const canonicalCwd = normalize(cwd);
+        const cwdRoot = getGitRoot(cwd) ?? findGitRootByDotGit(cwd);
+        const canonicalRoot = cwdRoot ? normalize(cwdRoot) : null;
+        if (allowContaining) {
+            const containing = candidates
+                .map((handle) => ({ handle, repoPath: normalize(handle.repoPath) }))
+                .filter(({ repoPath }) => isSameOrDescendant(repoPath, canonicalCwd))
+                .filter(({ repoPath }) => !canonicalRoot || isSameOrDescendant(canonicalRoot, repoPath))
+                .sort((a, b) => b.repoPath.length - a.repoPath.length);
+            if (containing.length > 0)
+                return containing[0].handle;
+        }
+        if (!canonicalRoot)
             return null;
-        const canonicalCwd = canonicalizePath(cwdRoot);
         const cwdMatches = candidates.filter((handle) => {
-            const stored = canonicalizePath(handle.repoPath);
-            return process.platform === 'win32'
-                ? stored.toLowerCase() === canonicalCwd.toLowerCase()
-                : stored === canonicalCwd;
+            return normalize(handle.repoPath) === canonicalRoot;
         });
         return cwdMatches.length === 1 ? cwdMatches[0] : null;
     }
@@ -1818,7 +1866,7 @@ export class LocalBackend {
         }
         // Resolve repo from optional param (re-reads registry on miss). An optional
         // `branch` param scopes the resolved handle to that branch's index (#2106).
-        const repo = await this.resolveRepo(p.repo, p.branch);
+        const repo = await this.selectToolRepository(p.repo, p.branch, { allowCwdDefault: method !== 'rename' });
         switch (method) {
             case 'query':
                 return this.withToolStaleness(repo, await this.query(repo, p));
@@ -3000,7 +3048,22 @@ export class LocalBackend {
         else if (isQualified) {
             // Parenthesised because the kind filter below is appended with AND, which
             // binds tighter than OR.
-            whereClause = `WHERE (n.id = $symName OR n.name = $symName)`;
+            // #3074: a repo-relative file path (e.g. "supabase/functions/_shared/crypto.ts")
+            // is the most natural way to name a File and is exactly what `target.filePath`
+            // reports, but the old clause only matched `n.id` (= "File:<path>") or basename
+            // `n.name`, so the same path the graph stores never resolved. Also match the
+            // repo-relative `n.filePath` exactly and via an anchored suffix (segment-boundary
+            // "ENDS WITH $suffix" where suffix is "/"+path) so "a.ts" does not spuriously
+            // match "mylib/a.ts" — same anchoring used in detect_changes (#2915).
+            const suffix = pathSuffixOf(name);
+            // File-path terms must be scoped to File nodes — n.filePath is shared by
+            // every symbol in the file, so an unlabeled predicate would turn
+            // "src/actions.ts" into every symbol in that file (bot review #3084 P1).
+            // LadybugDB does not allow label tests in WHERE (n:File), so scope via
+            // id prefix — File nodes are `File:<path>`.
+            whereClause = `WHERE (n.id = $symName OR n.name = $symName OR (n.id STARTS WITH $filePrefix AND (n.filePath = $symName OR n.filePath ENDS WITH $suffix)))`;
+            queryParams.suffix = suffix;
+            queryParams.filePrefix = 'File:';
         }
         else {
             whereClause = `WHERE n.name = $symName`;
@@ -3079,7 +3142,7 @@ export class LocalBackend {
         if (rows.length === 0)
             return { kind: 'not_found' };
         // Normalise row shape across object / tuple returns from LadybugDB.
-        const normalized = rows.map((r) => ({
+        let normalized = rows.map((r) => ({
             id: (r.id ?? r[0]),
             name: (r.name ?? r[1]),
             type: (r.type ?? r[2] ?? ''),
@@ -3088,6 +3151,14 @@ export class LocalBackend {
             endLine: (r.endLine ?? r[5]),
             ...(include_content ? { content: (r.content ?? r[6]) } : {}),
         }));
+        // An exact File path wins over anchored suffix candidates. Without this,
+        // `lib/a.ts` and `src/lib/a.ts` both score as File candidates and turn an
+        // otherwise unambiguous exact target into `ambiguous` (#3084 review P2).
+        if (isQualified) {
+            const exactFiles = normalized.filter((candidate) => candidate.id.startsWith('File:') && candidate.filePath === name);
+            if (exactFiles.length > 0)
+                normalized = exactFiles;
+        }
         // The COUNT can never legitimately be below the page it accompanies, so a
         // value under `normalized.length` means the count leg failed or returned an
         // unreadable shape. Keep the window size as the floor — reporting zero would
@@ -4942,6 +5013,7 @@ export class LocalBackend {
                     direction: params.direction,
                     suggestion,
                     recoverySuggestion,
+                    undetermined: true,
                 });
                 return pdgErr;
             }
@@ -4949,7 +5021,7 @@ export class LocalBackend {
                 error: message,
                 target: { name: params.target },
                 direction: params.direction,
-                impactedCount: 0,
+                impactedCount: null,
                 risk: 'UNKNOWN',
                 suggestion,
                 ...(recoverySuggestion ? { recoverySuggestion } : {}),
@@ -5036,6 +5108,7 @@ export class LocalBackend {
                         `(single-repo PDG impact). Remove them or use mode:'callgraph' for cross-repo fan-out.`,
                     target: crossDepthTarget,
                     direction,
+                    undetermined: true,
                 });
                 return pdgErr;
             }
@@ -5091,12 +5164,17 @@ export class LocalBackend {
                     error: `Target '${missing}' not found`,
                     target: notFoundTarget,
                     direction,
+                    undetermined: true,
                 })
                 : {
                     error: `Target '${missing}' not found`,
                     target: { name: target },
                     direction,
-                    impactedCount: 0,
+                    // #3074 follow-up: do not ship a normal-shaped 0/UNKNOWN blast radius
+                    // alongside the error — it reads as a real "nothing depends on this"
+                    // answer. Null marks UNDETERMINED (same as the ambiguous path) so a
+                    // consumer testing `impactedCount === 0` cannot misread a miss as safe.
+                    impactedCount: null,
                     risk: 'UNKNOWN',
                 };
         }
@@ -5200,6 +5278,10 @@ export class LocalBackend {
                     score: Number(c.score.toFixed(2)),
                     impactedCount: summary?.impactedCount ?? 0,
                     risk: summary?.risk ?? 'UNKNOWN',
+                    ...(summary?.riskSharedAxes !== undefined
+                        ? { riskSharedAxes: summary.riskSharedAxes }
+                        : {}),
+                    ...(summary?.riskScale !== undefined ? { riskScale: summary.riskScale } : {}),
                     direct: summary?.summary?.direct ?? 0,
                     ...(summary?.riskNote !== undefined ? { riskNote: summary.riskNote } : {}),
                     // Carry the explanation with the verdict. The single-symbol path
@@ -6092,6 +6174,10 @@ export class LocalBackend {
         const rawMaxChunks = process.env.IMPACT_MAX_CHUNKS?.trim();
         const parsedMaxChunks = rawMaxChunks ? Number(rawMaxChunks) : Number.NaN;
         const MAX_CHUNKS = Number.isInteger(parsedMaxChunks) && parsedMaxChunks >= 0 ? parsedMaxChunks : 10;
+        let processQueryFailed = false;
+        let moduleQueryFailed = false;
+        let enrichmentDegraded = false;
+        let moduleClassificationFailed = false;
         // `skipEnrichment` (ambiguous #2129 per-candidate probes) bypasses the
         // process/module aggregation passes entirely — those probes need only the
         // count + a count-based risk, so paying the bounded-but-real enrichment cost
@@ -6125,7 +6211,12 @@ export class LocalBackend {
                    p.entryPointId AS entryPointId, hits, minStep, p.stepCount AS stepCount,
                    ep.name AS epName, labels(ep)[0] AS epType, ep.filePath AS epFilePath
             ORDER BY pId
-          `, { ids }).catch(() => []);
+          `, { ids }).catch((err) => {
+                        processQueryFailed = true;
+                        enrichmentDegraded = true;
+                        logQueryError('impact:process-chunk', err);
+                        return [];
+                    });
                     for (const row of rows) {
                         const pId = row.pId ?? row[0];
                         const epId = row.entryPointId ?? row[3] ?? row.pId ?? row[0];
@@ -6173,6 +6264,8 @@ export class LocalBackend {
                     }
                 }
                 catch (e) {
+                    processQueryFailed = true;
+                    enrichmentDegraded = true;
                     logQueryError('impact:process-chunk', e);
                 }
             }
@@ -6187,7 +6280,11 @@ export class LocalBackend {
             MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
             WHERE p.id IN $pIds AND s.id IN $ids
             RETURN p.id AS pid, MIN(r.step) AS minStep
-          `, { pIds, ids: allImpactedIds }).catch(() => []);
+          `, { pIds, ids: allImpactedIds }).catch((err) => {
+                        enrichmentDegraded = true;
+                        logQueryError('impact:process-chunk-backfill', err);
+                        return [];
+                    });
                     for (const mr of missingRows) {
                         const pid = mr.pid ?? mr[0];
                         const minStep = mr.minStep ?? mr[1];
@@ -6203,6 +6300,7 @@ export class LocalBackend {
                     }
                 }
                 catch (e) {
+                    enrichmentDegraded = true;
                     logQueryError('impact:process-chunk-backfill', e);
                 }
             }
@@ -6250,7 +6348,12 @@ export class LocalBackend {
             RETURN c.heuristicLabel AS name, COUNT(DISTINCT s.id) AS hits
             ORDER BY hits DESC, name
             LIMIT 20
-          `, { ids: idsChunk }).catch(() => []);
+          `, { ids: idsChunk }).catch((err) => {
+                        moduleQueryFailed = true;
+                        enrichmentDegraded = true;
+                        logQueryError('impact:module-chunk', err);
+                        return [];
+                    });
                     for (const r of rows) {
                         const name = r.name ?? r[0] ?? null;
                         const hits = (r.hits ?? r[1]) || 0;
@@ -6260,6 +6363,8 @@ export class LocalBackend {
                     }
                 }
                 catch (e) {
+                    moduleQueryFailed = true;
+                    enrichmentDegraded = true;
                     logQueryError('impact:module-chunk', e);
                 }
             };
@@ -6280,7 +6385,12 @@ export class LocalBackend {
             MATCH (s)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
             WHERE s.id IN $ids
             RETURN DISTINCT c.heuristicLabel AS name
-          `, { ids: idsChunk }).catch(() => []);
+          `, { ids: idsChunk }).catch((err) => {
+                        enrichmentDegraded = true;
+                        moduleClassificationFailed = true;
+                        logQueryError('impact:direct-module-chunk', err);
+                        return [];
+                    });
                     for (const r of rows) {
                         const name = r.name ?? r[0] ?? null;
                         if (name)
@@ -6288,6 +6398,8 @@ export class LocalBackend {
                     }
                 }
                 catch (e) {
+                    enrichmentDegraded = true;
+                    moduleClassificationFailed = true;
                     logQueryError('impact:direct-module-chunk', e);
                 }
             };
@@ -6308,47 +6420,35 @@ export class LocalBackend {
                 return {
                     name,
                     hits,
-                    impact: directModuleNameSet.has(name) ? 'direct' : 'indirect',
+                    impact: moduleClassificationFailed
+                        ? 'classification-unavailable'
+                        : directModuleNameSet.has(name)
+                            ? 'direct'
+                            : 'indirect',
                 };
             });
         }
         // Risk scoring
         const processCount = affectedProcesses.length;
         const moduleCount = affectedModules.length;
-        let risk;
-        if (direction === 'upstream' && impacted.length === 0) {
-            // An upstream walk that resolved NO callers cannot support `LOW`. "Safe
-            // to change" is a claim ABOUT callers, and this walk found none to reason
-            // about: the symbol may be genuinely unused, or reached only through a
-            // reference class this index does not record — a property access on a
-            // plain object, or a bare-identifier read of a module-scope `Const`,
-            // neither of which mints a reference site today. Seeding `LOW` from an
-            // empty result is the same false-safe signal `anyKnownRisk` refuses to
-            // emit on the ambiguous-candidate path, and that #2687 removed by making
-            // an undetermined `impactedCount` `null` instead of `0`.
-            //
-            // Downstream is deliberately untouched: an empty downstream walk reports
-            // that this symbol resolved no callees, which is not a safety verdict.
-            risk = 'UNKNOWN';
-        }
-        else if (directCount >= 30 ||
-            processCount >= 5 ||
-            moduleCount >= 5 ||
-            impacted.length >= 200) {
-            risk = 'CRITICAL';
-        }
-        else if (directCount >= 15 ||
-            processCount >= 3 ||
-            moduleCount >= 3 ||
-            impacted.length >= 100) {
-            risk = 'HIGH';
-        }
-        else if (directCount >= 5 || impacted.length >= 30) {
-            risk = 'MEDIUM';
-        }
-        else {
-            risk = 'LOW';
-        }
+        const isFileTarget = symType === 'File' || String(symId).startsWith('File:');
+        const unusedAxes = unusedAxesForImpactWalk({
+            isFileTarget,
+            skipEnrichment,
+            maxChunks: MAX_CHUNKS,
+            processQueryFailed,
+            moduleQueryFailed,
+            impactedCount: impacted.length,
+            enrichmentTruncated: !skipEnrichment && MAX_CHUNKS > 0 && impacted.length > MAX_CHUNKS * CHUNK_SIZE,
+        });
+        const { risk, riskSharedAxes, riskScale } = scoreImpactRisk({
+            direction,
+            directCount,
+            processCount,
+            moduleCount,
+            impactedCount: impacted.length,
+            unusedAxes,
+        });
         // Build per-depth counts (always included, even in summaryOnly mode)
         const byDepthCounts = {};
         for (const [depth, items] of Object.entries(grouped)) {
@@ -6365,7 +6465,7 @@ export class LocalBackend {
             target: {
                 id: symId,
                 name: sym.name || sym[1],
-                type: symType,
+                type: isFileTarget ? symType || 'File' : symType,
                 filePath: sym.filePath || sym[2],
                 ...(beanMetadata ? { bean: beanMetadata } : {}),
                 ...(aopMetadata ? { aop: aopMetadata } : {}),
@@ -6373,17 +6473,26 @@ export class LocalBackend {
             direction,
             impactedCount: impacted.length,
             risk,
+            riskSharedAxes,
+            riskScale,
             ...(risk === 'UNKNOWN'
                 ? {
-                    riskNote: 'No callers resolved. Absence of edges is not evidence the symbol is unused: ' +
-                        'a caller reaching it through a reference class this index does not record — ' +
-                        'plain-object property access, a bare-identifier read of a module-scope const — ' +
-                        'produces no edge to find. Confirm with a text search before treating the ' +
-                        'change as safe.',
+                    riskNote: processQueryFailed || moduleQueryFailed
+                        ? 'Risk is unresolved because process/module enrichment failed. Observed counts ' +
+                            'are lower bounds; retry impact before treating the change as safe.'
+                        : unusedAxes.some((axis) => axis.reason === 'enrichment-truncated')
+                            ? 'Risk is unresolved because process/module enrichment was truncated. Observed ' +
+                                'counts are lower bounds; retry with a higher IMPACT_MAX_CHUNKS before ' +
+                                'treating the change as safe.'
+                            : 'No callers resolved. Absence of edges is not evidence the symbol is unused: ' +
+                                'a caller reaching it through a reference class this index does not record — ' +
+                                'plain-object property access, a bare-identifier read of a module-scope const — ' +
+                                'produces no edge to find. Confirm with a text search before treating the ' +
+                                'change as safe.',
                 }
                 : {}),
             ...epistemic,
-            ...(!traversalComplete && { partial: true }),
+            ...((!traversalComplete || enrichmentDegraded) && { partial: true }),
             summary: {
                 direct: directCount,
                 processes_affected: processCount,

package/dist/mcp/local/pdg-impact.d.ts

@@ -31,8 +31,10 @@ export declare function splitCalleeIds(raw: unknown): string[];
  * Bump on any breaking change to the PDG result fields.
  * v2: `startLine` in the result is now 1-based display (#2380), matching the
  * context/query/impact tools (was 0-based).
+ * v3: error envelopes use `impactedCount: null` when a target cannot be resolved
+ * (#3074), so consumers cannot read a miss as a measured zero.
  */
-export declare const PDG_RESULT_VERSION: 2;
+export declare const PDG_RESULT_VERSION: 3;
 /** A reachable dependence block resolved to its source statement. */
 export interface PdgStatement {
     /** 1-based source line where the statement's block starts. */
@@ -229,7 +231,7 @@ export interface PdgInterproceduralImpact {
 export interface PdgImpactBaseResult extends PdgImpactParityFields {
     mode: 'pdg';
     /** Contract version of the mode:'pdg' impact result shape; bump on any breaking change to the PDG result fields. */
-    pdgResultVersion: 2;
+    pdgResultVersion: 3;
     target: PdgImpactTarget;
     direction: 'upstream' | 'downstream';
     impactedCount: number;
@@ -296,11 +298,11 @@ export interface PdgImpactDegradedResult extends PdgImpactBaseResult {
 export interface PdgImpactErrorResult {
     mode?: 'pdg';
     /** Contract version of the mode:'pdg' impact result shape; bump on any breaking change to the PDG result fields. */
-    pdgResultVersion: 2;
+    pdgResultVersion: 3;
     error: string;
     target: PdgImpactTarget;
     direction: 'upstream' | 'downstream';
-    impactedCount: 0;
+    impactedCount: number | null;
     risk: 'UNKNOWN';
     suggestion?: string;
     recoverySuggestion?: string;
@@ -313,6 +315,8 @@ export declare function makePdgImpactErrorResult(input: {
     mode?: 'pdg';
     suggestion?: string;
     recoverySuggestion?: string;
+    /** True when analysis did not obtain a measured impact count. */
+    undetermined?: boolean;
 }): PdgImpactErrorResult;
 export declare function isPdgDegradedLayerStatus(layer: PdgLayerStatus): layer is PdgDegradedLayerStatus;
 export declare function makePdgLayerDegradedResult(input: {

package/dist/mcp/local/pdg-impact.js

@@ -109,8 +109,10 @@ export function splitCalleeIds(raw) {
  * Bump on any breaking change to the PDG result fields.
  * v2: `startLine` in the result is now 1-based display (#2380), matching the
  * context/query/impact tools (was 0-based).
+ * v3: error envelopes use `impactedCount: null` when a target cannot be resolved
+ * (#3074), so consumers cannot read a miss as a measured zero.
  */
-export const PDG_RESULT_VERSION = 2;
+export const PDG_RESULT_VERSION = 3;
 /**
  * FU-B-2 intra-block def→use line walk. Given a block's self REACHING_DEF
  * def→use line PAIRS (every `defLine → useLine` step decoded from the edge
@@ -469,7 +471,10 @@ export function makePdgImpactErrorResult(input) {
         error: input.error,
         target: input.target,
         direction: input.direction,
-        impactedCount: 0,
+        // #3074 follow-up + P2 review: an unmeasured PDG result must not ship a
+        // confident-looking 0 blast radius. null marks UNDETERMINED, so a consumer
+        // testing === 0 cannot misread a miss or failed query as safe.
+        impactedCount: input.undetermined ? null : 0,
         risk: 'UNKNOWN',
         ...(input.suggestion ? { suggestion: input.suggestion } : {}),
         ...(input.recoverySuggestion ? { recoverySuggestion: input.recoverySuggestion } : {}),

package/dist/mcp/repository-policy.d.ts

@@ -20,10 +20,14 @@ export declare class McpRepositoryPolicy {
     private repoForArgs;
     private normalizeToolArgs;
     private listAllowedRepos;
-    requiresExplicitRepo(backend: LocalBackend): Promise<boolean>;
+    toolSchemaRepoRequirements(backend: LocalBackend): Promise<{
+        readOnlyRequiresRepo: boolean;
+        mutatingRequiresRepo: boolean;
+    }>;
     private listReposPage;
     private callTool;
     private resolveRepo;
+    private selectToolRepository;
     assertResourceUri(uri: string): void;
     resourceTemplateAllowed(uriTemplate: string): boolean;
     toolAllowed(toolName: string): boolean;

package/dist/mcp/repository-policy.js

@@ -134,10 +134,40 @@ export class McpRepositoryPolicy {
             };
         });
     }
-    async requiresExplicitRepo(backend) {
-        if (this.defaultRepo)
-            return false;
-        return (await this.listAllowedRepos(backend)).length > 1;
+    async toolSchemaRepoRequirements(backend) {
+        if (this.defaultRepo) {
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: false };
+        }
+        // Runtime selection is based on the configured allowlist, not on which
+        // entries happen to remain visible in a later registry refresh. Keep the
+        // advertised schema aligned with repoForArgs() when that listing shrinks.
+        if (this.restricted) {
+            const requiresRepo = this.allowed.length > 1;
+            return {
+                readOnlyRequiresRepo: requiresRepo,
+                mutatingRequiresRepo: requiresRepo,
+            };
+        }
+        // One fresh listing supplies both schema decisions. Besides keeping the
+        // advertised contract internally consistent, this avoids doing two full
+        // per-repo staleness fan-outs for every tools/list request.
+        const visibleRepos = await this.listAllowedRepos(backend);
+        if (visibleRepos.length <= 1) {
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: false };
+        }
+        try {
+            // listAllowedRepos() refreshed this backend immediately above. Resolve
+            // against that exact cache snapshot instead of racing another registry
+            // read; only read-only schemas may advertise the cwd-derived default.
+            await backend.selectToolRepository(undefined, undefined, {
+                allowCwdDefault: true,
+                refreshRegistry: false,
+            });
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: true };
+        }
+        catch {
+            return { readOnlyRequiresRepo: true, mutatingRequiresRepo: true };
+        }
     }
     async listReposPage(backend, params) {
         const { limit, offset } = parseListReposPagination(params, {
@@ -186,6 +216,17 @@ export class McpRepositoryPolicy {
         const selected = this.repoForArgs(repo === undefined ? undefined : { repo });
         return backend.resolveRepo(selected?.path, branch);
     }
+    async selectToolRepository(backend, repo, branch, options) {
+        if (!this.configured)
+            return backend.selectToolRepository(repo, branch, options);
+        if (!this.restricted) {
+            return backend.selectToolRepository(repo ?? this.defaultRepo?.path, branch, options);
+        }
+        const selected = this.repoForArgs(repo === undefined ? undefined : { repo });
+        // Restricted policies never allow cwd to select outside the configured
+        // set; once policy supplies an explicit path, the public resolver is enough.
+        return backend.resolveRepo(selected?.path, branch);
+    }
     assertResourceUri(uri) {
         if (!this.restricted)
             return;
@@ -255,6 +296,9 @@ export class McpRepositoryPolicy {
                 if (property === 'resolveRepo') {
                     return (repo, branch) => policy.resolveRepo(target, repo, branch);
                 }
+                if (property === 'selectToolRepository') {
+                    return (repo, branch, options) => policy.selectToolRepository(target, repo, branch, options);
+                }
                 if (property === 'getContext' && policy.restricted) {
                     return (repoId) => {
                         if (!repoId || !policy.uniqueAllowedContextNames.has(repoId.toLowerCase()))