@mrclrchtr/supi-code-intelligence 2.0.6 → 2.2.0

package/src/tool/guidance.ts

@@ -2,6 +2,11 @@
 //
 // Each code_* tool owns its complete promptGuidelines here.
 // Runtime registration data (name, parameters, run) lives in specs.ts.
+//
+// Cross-tool steering is centralized (authored once on its natural-home tool) and
+// some tools have empty promptGuidelines by design: all code_* tools are always
+// active together, so a steering bullet on one tool is always co-visible. See
+// docs/adr/0013-centralized-code-intelligence-prompt-steering-assumes-all-tools-active.md.
 
 import type { CodeIntelligenceToolName } from "../types/index.ts";
 
@@ -19,94 +24,78 @@ export type CodeIntelligenceToolPromptSurfaceMap = Record<
 export const CODE_INTELLIGENCE_TOOL_PROMPT_SURFACES: CodeIntelligenceToolPromptSurfaceMap = {
   code_resolve: {
     description:
-      "Resolve human or code references into precise file/range/symbol targets and stable target handles. Use when a symbol, file, or code reference is ambiguous and needs precise resolution. Returns targetId and spanId handles that can be passed to code_graph, code_impact, and code_refactor_plan. Supports anchored (file + line + character), file-only, and query/symbol inputs. Anchored coordinates resolve a real symbol target from provider-backed evidence: an exact identifier coordinate resolves to a named target; a declaration-header coordinate (e.g. an `export` keyword) snaps to the symbol name anchor only when unambiguous. Whitespace/comment/non-symbol coordinates fail honestly and recommend code_inspect. Does not fall back to text search for symbol resolution; ambiguous results return ranked candidates with target IDs for every shown item. Output is truncated to 2000 lines / 50KB.",
+      "Resolve references to evidence-backed code targets and stable targetId/spanId handles for follow-up code_* tools. Accepts query/symbol/file or anchored file+line+character; anchored resolution snaps only to real provider-backed symbols, and whitespace/comment/non-symbol points fail with code_inspect guidance. No text-search fallback; ambiguous results return ranked candidates. Truncates at 2000 lines/50KB.",
     promptSnippet: "code_resolve — resolve references into precise targets and target handles",
     promptGuidelines: [
-      "Use code_resolve when a symbol, file, or code reference is ambiguous and needs precise resolution.",
-      "Prefer code_resolve as the entry point before code_orientation, code_graph, code_impact, or code_refactor_plan — its targetId replaces fragile file/line/character coordinates.",
-      "When code_resolve returns ambiguous results with ranked candidates, pick one and use file + line + character for follow-up resolution.",
+      "Use code_resolve first for ambiguous or symbol-only targets, before graph/impact/refactor/orientation; if resolve returns ranked candidates, narrow with a candidate file + line + character.",
     ],
   },
   code_inspect: {
     description:
-      "Inspect one precise point in a file and return factual syntax, symbol, hover, definition, diagnostics, and code-action information. Use when you need to understand exactly what is at a position without choosing between provider-specific substrate tools. When some providers are unavailable, returns best-effort sections with explicit unavailable notes instead of heuristic guesses. Code action titles are advisory only — there is no tool to execute them yet. Output is truncated to 2000 lines / 50KB.",
+      "Inspect one exact file position for syntax, symbol, hover/definition, nearby diagnostics, and code-action titles. Requires file, line, and character; use for point facts, not broad orientation. Unavailable providers are disclosed; code actions are advisory only. Truncates at 2000 lines/50KB.",
     promptSnippet: "code_inspect — factual point inspection",
-    promptGuidelines: [
-      "Use code_inspect for factual point inspection at one precise file position.",
-      "Provide `file`, `line`, and `character` — code_inspect is intentionally point-based.",
-      "Prefer code_inspect over code_orientation for point-level facts when no symbol target can be resolved.",
-    ],
+    // No guidelines: selection is steered by code_orientation's bullet plus this
+    // self-sufficient description. See ADR 0013 (all code_* tools always active).
+    promptGuidelines: [],
   },
   code_orientation: {
     description:
-      "Primary code-orientation tool for understanding a project, discovered module, directory, file, or symbol before choosing surgical follow-up tools. Use `focus` for a workspace-relative path or discovered module name; omit `focus` for project orientation. Use `focus` + `line` + `character` for symbol orientation, or pass `targetId` from `code_resolve`; `targetId` takes precedence over focus/coordinates and stale target IDs do not fall back. Symbol orientation returns definitions, JSDoc/TSDoc docs, local diagnostics near the target, and Read Next guidance; relation evidence belongs in code_graph, impact evidence in code_impact, and health/status in code_health. Not a point-inspection tool — use code_inspect for exact position facts. `maxResults` caps each rendered list and defaults to 10. Output is truncated to 2000 lines / 50KB.",
+      "Orient around the workspace, module, directory, file, or resolved symbol before surgical work. Omit focus for workspace orientation; use focus for a path/module, or targetId/focus+line+character for symbol orientation. Directory focus may surface local instruction files (CLAUDE.md, AGENTS.md). targetId wins and stale IDs error. Returns landmarks, docs, local diagnostics, and read-next guidance; relations/impact/health belong in code_graph/code_impact/code_health. maxResults caps lists; output is truncated to 2000 lines / 50KB.",
     promptSnippet: "code_orientation — project/module/file/symbol orientation",
     promptGuidelines: [
       "Use `code_orientation({ focus })` for first-pass project/package/directory/file orientation before `bash`/`read`.",
+      "Use directory focus (for example `packages/foo`) to surface local instruction files before package work.",
       "Use code_resolve first for bare symbol names, then pass the resulting targetId to code_orientation.",
       "Use code_graph/code_impact/code_health for relations, impact, or full health instead of asking code_orientation for those sections.",
     ],
   },
   code_graph: {
     description:
-      'Unified relation-graph tool — replaces code_references, code_calls, and code_implementations. Resolves a target once and dispatches to the appropriate analysis service per requested relation. Defaults to ["references"] when `relations` is omitted. Each relation is best-effort: unavailable substrates skip with a note rather than failing the whole call. Each relation annotates its evidence source. The tests relation displays discovery provenance (semantic+conventions or conventions-only) separately from any extracted test labels. `callees` is structural/direct-scope evidence: it reports call expressions by source shape, not symbol identity, and excludes calls inside nested function/method/callback scopes — use `references` on a resolved target for identity-aware incoming callers. Pass `calleeDepth: "deep"` to include callees from nested scopes. `imports` and `exports` use file-level tree-sitter analysis; `tests` discovers companion test files and labels. Targeted graph results include Read Next guidance for source ranges worth inspecting via `read`. `scope` (not `path`) narrows by workspace-relative directory/package. Use code_resolve first to get a targetId, then pass it to code_graph. Output is truncated to 2000 lines / 50KB.',
+      'Analyze relation evidence for a resolved target or coordinates: references, structural callees, imports/exports, implementations, and tests. Defaults to references; relations:["all"] expands all families. Per-relation substrate failures are disclosed. Callees are syntax/direct-scope source-shape calls, not symbol identity; calleeDepth:"deep" includes nested scopes. Scope narrows by workspace path; targetId from code_resolve is preferred. Truncates at 2000 lines/50KB.',
     promptSnippet: "code_graph — semantic and structural relation graph",
-    promptGuidelines: [
-      "Use code_graph to find references, direct structural calls, and implementations for a target.",
-      'Default `relations` is ["references"]; use `relations: ["callees"]` or `["implements"]` for those, or `relations: ["all"]` to expand to every relation family in one call.',
-      "After code_graph, follow up with code_orientation on individual results for type or definition context.",
-      'Pass `calleeDepth: "deep"` to include callees from nested function/method/callback scopes (default `"direct"` excludes them).',
-      'Suggested relations by target kind: For functions/methods: `["references", "callees", "tests"]` — For interfaces/types/classes/enums: `["references", "implements"]` — For files/modules: `["imports", "exports"]` — For tests: `["tests"]`.',
-    ],
+    // No guidelines: selection is steered by this self-sufficient description plus
+    // code_impact's "use code_graph instead of code_impact" bullet. See ADR 0013.
+    promptGuidelines: [],
   },
   code_impact: {
     description:
-      "Estimate blast radius and downstream impact for a target or user-supplied change set before making edits. `changeSetFiles` are explicit workspace-relative files to analyze as in scope for a proposed/current change; they are not inferred from git and carry no line-level diff evidence. Uses semantic evidence for target-based impact and merges semantic references for symbols defined in change-set files when available. Includes Read Next guidance for source ranges worth inspecting via `read` before editing. Does not fall back to heuristic text search. Use a resolved target for precise semantic reference-based impact. Output is truncated to 2000 lines / 50KB.",
+      "Estimate blast radius for a resolved target or user-supplied changeSetFiles before editing. changeSetFiles are explicit files, not inferred from git and no line-level diff; change-only requests report insufficient evidence. Uses semantic references plus deterministic test discovery when available; no heuristic search fallback. Output includes read-next guidance; truncates at 2000 lines/50KB.",
     promptSnippet: "code_impact — blast radius and impact",
     promptGuidelines: [
-      "Use code_impact before edits to estimate blast radius and follow-up checks.",
-      "Use code_graph instead of code_impact when you only need a plain reference list without impact analysis.",
+      "Use code_graph instead of code_impact when you only need a plain reference list.",
     ],
   },
   code_find: {
     description:
-      'Unified ranked code search with strict mode dispatch: default/`mode: "text"` is literal ripgrep, `mode: "regex"` is ripgrep regex, `mode: "semantic"` is LSP workspace-symbol search, and `mode: "ast"` is tree-sitter structured search. `mode: "ast"` requires `kind` and currently supports `definition`, `import`, `export`, `call`, `type`, `interface`, `class`, `method`, `enum`, and `test`. `mode: "text"`, `mode: "regex"`, and `mode: "semantic"` do not accept `kind`. `code_find` with `mode: "semantic"` does not silently fall back to text search, and unsupported mode/kind combinations fail. AST `call` mode matches call-site identifiers by name, not by symbol identity; use `code_graph` references for identity-aware callers of a resolved target. Output is truncated to 2000 lines / 50KB.',
+      'Search code with explicit modes: text literal (default), regex, semantic workspace-symbol, or ast structured. mode:"ast" requires `kind` (definition/import/export/call/type/interface/class/method/enum/test); text/regex/semantic reject kind. Semantic mode uses LSP only and does not silently fall back. AST call matches written call-site names, not by symbol identity; use code_graph references on a resolved target for symbol-identity-aware callers. Truncates at 2000 lines/50KB.',
     promptSnippet: "code_find — unified ranked code search",
     promptGuidelines: [
-      "Use code_find as the sole code search tool for literal text, regex, semantic workspace-symbol, or AST structured search.",
-      'code_find with `mode: "ast"` requires `kind` and supports `definition`, `import`, `export`, `call`, `type`, `interface`, `class`, `method`, `enum`, and `test`.',
-      'code_find with `mode: "text"`, `mode: "regex"`, or `mode: "semantic"` does not accept `kind`.',
-      'code_find with `mode: "semantic"` does not fall back to text search and fails when semantic capability is unavailable.',
-      'AST `call` mode matches call-site identifiers by name only; use `code_graph` with `relations: ["references"]` on a resolved target for symbol-identity-aware callers.',
+      "Use code_find for explicit text, regex, semantic symbol, or AST search; use code_graph references for symbol-identity callers.",
     ],
   },
   code_refactor_plan: {
     description:
-      'Pure planner: previews a precise semantic refactor plan without mutating files and returns a planId for later use with code_refactor_apply. Supports rename_symbol plus extract_function/extract_variable when the active LSP can return precise edits. Legacy `operation: "rename"` is accepted as a compatibility alias. This tool never mutates files. Output is truncated to 2000 lines / 50KB.',
+      "Preview a semantic refactor plan and return planId; never mutates files. Supports rename_symbol (rename alias) and extract_function/extract_variable when LSP returns precise edits. Requires targetId or anchored file+line+character, plus operation-specific newName/range. Apply separately with code_refactor_apply. Truncates at 2000 lines/50KB.",
     promptSnippet: "code_refactor_plan — preview a precise workflow refactor plan",
     promptGuidelines: [
-      'Use `operation: "rename_symbol"` with code_refactor_plan for symbol renames. Legacy `operation: "rename"` is accepted as a compatibility alias.',
-      'Use `operation: "extract_function"` or `"extract_variable"` with a 1-based `range` and `newName` when the LSP advertises precise extract code actions.',
-      "code_refactor_plan is a pure planner — it returns a planId. Use code_refactor_apply with that planId to execute.",
+      "Use code_refactor_plan to preview rename/extract edits only; mutate later with code_refactor_apply and the returned planId.",
     ],
   },
   code_refactor_apply: {
     description:
-      "Sole mutator in the refactor workflow: applies a previously stored plan by planId. Revalidates the plan and checks file fingerprints, mutating files only when the plan is still fresh. Output is truncated to 2000 lines / 50KB.",
+      "Apply a stored refactor plan by planId. Revalidates plan freshness and file fingerprints before mutating; does not compose new plans. Truncates at 2000 lines/50KB.",
     promptSnippet: "code_refactor_apply — apply a stored refactor plan",
     promptGuidelines: [
-      "Use code_refactor_apply to execute a plan generated by code_refactor_plan.",
-      "Use code_refactor_plan first to obtain a planId, then code_refactor_apply to execute it.",
+      "Use code_refactor_apply only with a planId returned by code_refactor_plan.",
     ],
   },
   code_health: {
     description:
-      "Summarize diagnostics, language server status, dirty workspace signals, coverage, and unused-code findings. Pass refresh: true to recover stale diagnostics before checking. Use scope to narrow to a specific file or package. Use include to request specific sections: diagnostics, servers, dirty, coverage, unused. Defaults to summary level (counts); use level: detailed for per-file listings. Output is truncated to 2000 lines / 50KB.",
+      "Report workspace health: diagnostics, language-server status, dirty files, coverage, and unused code. Use scope/include/level to narrow; refresh:true recovers stale diagnostics. Missing coverage/unused reports are disclosed. Truncates at 2000 lines/50KB.",
     promptSnippet:
       "code_health — diagnostics, server status, coverage, unused-code, and workspace health",
     promptGuidelines: [
-      "Use code_health to check for diagnostics, language server status, dirty workspace state, coverage, or unused-code signals.",
-      "Pass `refresh: true` to code_health to recover stale diagnostics before checking.",
+      "Use code_health for diagnostics/server/dirty/coverage/unused health; pass refresh:true to code_health before relying on stale diagnostics.",
     ],
   },
 };

package/src/tool/health/markdown.ts

@@ -5,77 +5,19 @@
  * readable markdown sections keyed by requested `include` values.
  */
 
-import type { CoverageWarningReport } from "../../analysis/coverage/coverage-warnings.ts";
-import type { GitContext } from "../../analysis/signals/git.ts";
 import { formatGitContext } from "../../analysis/signals/git.ts";
-
-export type HealthSection = "diagnostics" | "servers" | "dirty" | "coverage" | "unused";
-
-export interface HealthServerInfo {
-  name: string;
-  root: string;
-  fileTypes: string[];
-  status: string;
-}
-
-export interface HealthDiagnosticEntry {
-  file: string;
-  errors: number;
-  warnings: number;
-}
-
-export interface HealthCoverageEntry {
-  file: string;
-  pct: number;
-}
-
-export interface HealthCoverageData {
-  available: boolean;
-  entries: HealthCoverageEntry[];
-}
-
-export interface HealthUnusedExportEntry {
-  file: string;
-  name: string;
-}
-
-export interface HealthUnusedData {
-  available: boolean;
-  files: string[];
-  exports: HealthUnusedExportEntry[];
-}
-
-/** A suggested code action at a specific diagnostic location. */
-export interface CodeActionSuggestion {
-  file: string;
-  line: number;
-  title: string;
-  kind?: string;
-}
-
-export interface HealthData {
-  includedSections: HealthSection[];
-  lspAvailable: boolean;
-  lspStatus: string;
-  recovered: boolean;
-  /** Structural (tree-sitter) substrate readiness. Undefined when not evaluated. */
-  structuralStatus?: string;
-  diagnostics: HealthDiagnosticEntry[];
-  servers: HealthServerInfo[];
-  gitContext: GitContext | null;
-  scopeFilter: string | null;
-  level: "summary" | "detailed";
-  /** Code action suggestions collected from LSP (only populated in detailed mode). */
-  codeActions: CodeActionSuggestion[] | null;
-  coverage: HealthCoverageData | null;
-  unused: HealthUnusedData | null;
-  /** Coverage warnings for degraded semantic/structural substrate. Undefined when fully healthy. */
-  degradedCoverage?: CoverageWarningReport;
-  /** Seconds since diagnostics were last refreshed, or undefined if never refreshed. */
-  diagnosticAgeSeconds?: number;
-}
-
-export function renderHealthResult(data: HealthData, cwd: string): string {
+import type { HealthData, HealthResultAssembly } from "../result/health.ts";
+
+export type {
+  CodeActionSuggestion,
+  HealthCoverageData,
+  HealthData,
+  HealthSection,
+  HealthUnusedData,
+} from "../result/health.ts";
+
+export function renderHealthResult(result: HealthResultAssembly, cwd: string): string {
+  const data = result.data;
   const lines: string[] = ["## Code Health", ""];
 
   renderStatusLine(lines, data);

package/src/tool/health/orchestrate.ts

@@ -15,8 +15,8 @@ import {
   gatherCoverageEvalInput,
 } from "../../analysis/coverage/coverage-warnings.ts";
 import { loadPrioritizationSignals } from "../../analysis/signals/project.ts";
-import type { CodeIntelResult, HealthDetails } from "../../types/index.ts";
-import type { HealthData, HealthSection } from "./markdown.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
+import { assembleHealthResult, type HealthData, type HealthSection } from "../result/health.ts";
 import { renderHealthResult } from "./markdown.ts";
 import { collectCodeActions, collectDiagnostics } from "./sections/diagnostics.ts";
 import {
@@ -138,22 +138,14 @@ export async function executeHealth(
     diagnosticAgeSeconds,
   };
 
-  const evidenceLists = buildHealthEvidenceLists(gitContext);
-  const content = renderHealthResult(data, cwd);
+  const assembly = assembleHealthResult(data, buildHealthEvidenceLists(gitContext));
+  const content = renderHealthResult(assembly, cwd);
 
   return {
     content,
     details: {
       type: "health",
-      data: {
-        lspAvailable: data.lspAvailable,
-        lspStatus: data.lspStatus,
-        recovered: data.recovered,
-        structuralStatus: data.structuralStatus,
-        diagnosticFileCount: data.diagnostics.length,
-        serverCount: data.servers.length,
-        evidenceLists,
-      } satisfies HealthDetails,
+      data: assembly.details,
     },
   };
 }

package/src/tool/impact/analysis.ts

@@ -4,7 +4,6 @@
 import * as path from "node:path";
 import type { buildArchitectureModel } from "../../analysis/architecture/discovery.ts";
 import { findModuleForPath, getDependents } from "../../analysis/architecture/model.ts";
-import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
 import type { CodeProvider } from "../../analysis/provider.ts";
 import type { ReferenceCollection } from "../../analysis/references/semantic-refs.ts";
 import type { ResolvedTargetData } from "../../analysis/target/types.ts";
@@ -16,7 +15,6 @@ import {
   type TestAnchorMap,
 } from "../../analysis/tests/likely-tests.ts";
 import { buildTestSurfaceDetails } from "../../analysis/tests/test-discovery.ts";
-import type { AffectedDetails, ImpactDetails } from "../../types/index.ts";
 import type { ImpactAnalysis } from "./types.ts";
 
 // ── Shared analysis ────────────────────────────────────────────────────
@@ -220,28 +218,3 @@ export function computeOmittedCount(
 ): number {
   return externalRefs + Math.max(0, affectedFileCount - (maxResults ?? 8));
 }
-
-// biome-ignore lint/complexity/useMaxParams: detail assembly keeps shared counts, queries, and signals explicit for both surfaces
-export function buildDetailsData(
-  analysis: ImpactAnalysis,
-  directCount: number,
-  omittedCount: number,
-  nextQueries: string[],
-  prioritySignals: AffectedDetails["prioritySignals"],
-  evidenceLists: EvidenceListMetadata[] = [],
-): AffectedDetails | ImpactDetails {
-  return {
-    confidence: analysis.confidence,
-    directCount,
-    downstreamCount: analysis.downstreamCount,
-    riskLevel: analysis.riskLevel,
-    checkNext: analysis.checkNext,
-    likelyTests: analysis.likelyTests,
-    likelyTestCommands: analysis.likelyTestCommands,
-    omittedCount,
-    evidenceLists,
-    nextQueries,
-    prioritySignals,
-    tests: analysis.tests,
-  };
-}

package/src/tool/impact/change-set-impact.ts

@@ -10,7 +10,8 @@ import type { ResolvedTargetData } from "../../analysis/target/types.ts";
 import type { ChangeSetFileEntry } from "../../analysis/tests/likely-tests.ts";
 import { normalizeChangeSet } from "../../analysis/tests/likely-tests.ts";
 import type { CodeIntelResult } from "../../types/index.ts";
-import { analyzeChangeSet, buildDetailsData, type ChangeSetSemanticImpact } from "./analysis.ts";
+import { assembleImpactDetails } from "../result/impact.ts";
+import { analyzeChangeSet, type ChangeSetSemanticImpact } from "./analysis.ts";
 import { renderChangeSetImpact } from "./markdown.ts";
 import { unavailableImpactResult } from "./result.ts";
 import type { ImpactAnalysis, ImpactInput } from "./types.ts";
@@ -59,7 +60,7 @@ export async function executeChangeSetImpact(
       prioritySignals,
     }) + evidenceNote;
 
-  const detailsData = buildDetailsData(
+  const detailsData = assembleImpactDetails(
     analysis,
     changeSetFiles.length,
     0,

package/src/tool/impact/execute.ts

@@ -30,6 +30,7 @@ export interface CodeImpactToolParams {
 }
 
 /** Execute the public code_impact tool. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: target workflow + pipeline orchestration stays together for clarity
 export async function executeImpactTool(
   params: CodeImpactToolParams,
   ctx: CodeIntelToolExecCtx,
@@ -38,6 +39,32 @@ export async function executeImpactTool(
 
   const hasChangeSetInputs = (params.changeSetFiles?.length ?? 0) > 0 || Boolean(params.change);
 
+  // ── Deep seam: resolve targetId through the session target workflow ──
+  // Replaces expandTargetId pipeline stage for targetId expansion.
+  if (!hasChangeSetInputs && params.targetId) {
+    const outcome = await ctx.session.resolveTarget(
+      { targetId: params.targetId },
+      { fileLevelAllowed: false, nameAnchorRequired: false, waitForSemantic: false },
+    );
+
+    if (outcome.kind === "resolved") {
+      params.file = outcome.entry.file;
+      params.line = outcome.entry.displayLine;
+      params.character = outcome.entry.displayCharacter;
+      params.symbol = outcome.entry.name ?? undefined;
+    } else if (outcome.kind !== "no-target") {
+      const msg =
+        outcome.kind === "invalid-input"
+          ? outcome.message
+          : outcome.kind === "unavailable"
+            ? outcome.reason
+            : "Target resolution failed. Verify the targetId is valid.";
+      return impactErrorResult(msg, {
+        nextQueries: ["Use `code_resolve` to resolve a target first"],
+      });
+    }
+  }
+
   return runPipe(
     params,
     ctx,

package/src/tool/impact/file-level-impact.ts

@@ -8,7 +8,8 @@ import { summarizePrioritySignalsForFiles } from "../../analysis/signals/project
 import type { ResolvedTargetGroupData } from "../../analysis/target/types.ts";
 import { buildTestAnchorMap } from "../../analysis/tests/likely-tests.ts";
 import type { CodeIntelResult } from "../../types/index.ts";
-import { analyzeReferenceImpact, buildDetailsData, computeOmittedCount } from "./analysis.ts";
+import { assembleImpactDetails } from "../result/impact.ts";
+import { analyzeReferenceImpact, computeOmittedCount } from "./analysis.ts";
 import { renderImpactFileLevel } from "./markdown.ts";
 import type { ImpactInput } from "./types.ts";
 
@@ -60,7 +61,7 @@ export async function executeFileLevelImpact(
     cwd,
   });
 
-  const detailsData = buildDetailsData(
+  const detailsData = assembleImpactDetails(
     analysis,
     aggregated.refs.length,
     computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, input.maxResults),

package/src/tool/impact/result.ts

@@ -1,21 +1,2 @@
-import type { CodeIntelResult } from "../../types/index.ts";
-
-export function unavailableImpactResult(content: string, nextQueries: string[]): CodeIntelResult {
-  return {
-    content,
-    details: {
-      type: "impact",
-      data: {
-        confidence: "unavailable",
-        directCount: 0,
-        downstreamCount: 0,
-        riskLevel: "low" as const,
-        checkNext: [],
-        likelyTests: [],
-        likelyTestCommands: [],
-        omittedCount: 0,
-        nextQueries,
-      },
-    },
-  };
-}
+/** Compatibility export for impact result assembly. */
+export { unavailableImpactResult } from "../result/impact.ts";

package/src/tool/impact/single-impact.ts

@@ -10,7 +10,8 @@ import { summarizePrioritySignalsForFiles } from "../../analysis/signals/project
 import type { ResolvedTargetData } from "../../analysis/target/types.ts";
 import { buildTestAnchorMap } from "../../analysis/tests/likely-tests.ts";
 import type { CodeIntelResult } from "../../types/index.ts";
-import { analyzeReferenceImpact, buildDetailsData, computeOmittedCount } from "./analysis.ts";
+import { assembleImpactDetails } from "../result/impact.ts";
+import { analyzeReferenceImpact, computeOmittedCount } from "./analysis.ts";
 import { renderImpactSingle } from "./markdown.ts";
 import type { ImpactInput } from "./types.ts";
 
@@ -58,7 +59,7 @@ export async function executeSingleImpact(
     items: refs.refs,
     maxResults,
   }).metadata;
-  const detailsData = buildDetailsData(
+  const detailsData = assembleImpactDetails(
     analysis,
     refs.refs.length,
     computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, input.maxResults),