@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/src/session/graph/collect.ts

@@ -1,5 +1,10 @@
 /** Presentation-neutral relation collection used by the session-owned graph workflow. */
 
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+  unavailableCodeQuery,
+} from "@mrclrchtr/supi-code-runtime/api";
 import type { CodeProvider } from "../../analysis/provider.ts";
 import {
   readNextEnclosingScope,
@@ -25,6 +30,7 @@ export interface CollectRelationOptions {
   semanticReadinessError: string | null;
   anchorKind: AnchorKind;
   calleeDepth?: "direct" | "deep";
+  requestControl?: CodeRequestControl;
 }
 
 /** Collect one evidence-backed graph relation without rendering it. */
@@ -46,6 +52,7 @@ export async function collectRelation(
         return collectImplementationsRelation(options);
     }
   } catch (error) {
+    if (isCodeRequestInterruption(error, options.requestControl)) throw error;
     return {
       kind: "unavailable",
       rel: relation,
@@ -61,7 +68,11 @@ async function collectReferences(options: CollectRelationOptions): Promise<Graph
 
   const result = await collectCallers(options.file, options.position, options.displayName, {
     cwd: options.cwd,
-    provider: { references: options.provider.references },
+    provider: {
+      references: async (file, position) =>
+        options.provider?.references(file, position, options.requestControl) ??
+        unavailableCodeQuery("References unavailable"),
+    },
   });
   if (result.confidence === "unavailable") {
     return { kind: "unavailable", rel: "references", message: "References unavailable" };
@@ -118,6 +129,7 @@ async function collectCalleesRelation(options: CollectRelationOptions): Promise<
     { cwd: options.cwd, provider: { calleesAt: options.provider.calleesAt } },
     undefined,
     options.calleeDepth ?? "direct",
+    options.requestControl,
   );
   if (result.confidence === "unavailable") {
     return { kind: "unavailable", rel: "callees", message: "Callees unavailable" };
@@ -161,7 +173,11 @@ async function collectImplementationsRelation(
 
   const result = await collectImplementations(options.file, options.position, options.displayName, {
     cwd: options.cwd,
-    provider: { implementation: options.provider.implementation },
+    provider: {
+      implementation: async (file, position) =>
+        options.provider?.implementation(file, position, options.requestControl) ??
+        unavailableCodeQuery("Implementations unavailable"),
+    },
   });
   if (result.confidence === "unavailable") {
     return { kind: "unavailable", rel: "implements", message: "Implementations unavailable" };

package/src/session/graph-workflow.ts

@@ -54,7 +54,9 @@ export async function runGraphWorkflow(
       maxResults: request.maxResults,
     },
     deps,
+    control,
   );
+  throwIfAborted(control);
   if (targetOutcome.kind === "target-group") {
     return {
       kind: "invalid-input",
@@ -64,12 +66,13 @@ export async function runGraphWorkflow(
   if (targetOutcome.kind !== "resolved") return targetOutcome;
 
   const entry = targetOutcome.entry;
-  const semanticReadinessError = await getSemanticReadinessError(
+  const semanticReadinessError = await getSemanticReadinessError({
     relations,
-    entry.file,
-    deps.capability,
-    deps.cwd,
-  );
+    file: entry.file,
+    capability: deps.capability,
+    cwd: deps.cwd,
+    control,
+  });
   const provider = deps.capability.getProvider(deps.cwd);
   const maxResults = request.maxResults ?? 8;
   const displayName =
@@ -94,9 +97,11 @@ export async function runGraphWorkflow(
         semanticReadinessError,
         anchorKind: entry.anchorKind,
         calleeDepth: request.calleeDepth,
+        requestControl: control,
       }),
     );
   }
+  throwIfAborted(control);
 
   if (sections.length > 0 && sections.every((section) => section.kind === "unavailable")) {
     return {
@@ -127,16 +132,18 @@ function normalizeRelations(
   return requested as readonly GraphRelationKind[];
 }
 
-async function getSemanticReadinessError(
-  relations: readonly GraphRelationKind[],
-  file: string,
-  capability: CapabilityAdapter,
-  cwd: string,
-): Promise<string | null> {
+async function getSemanticReadinessError(options: {
+  relations: readonly GraphRelationKind[];
+  file: string;
+  capability: CapabilityAdapter;
+  cwd: string;
+  control?: WorkflowControl;
+}): Promise<string | null> {
+  const { relations, file, capability, cwd, control } = options;
   if (!relations.some((relation) => relation === "references" || relation === "implements")) {
     return null;
   }
-  const readiness = await capability.ensureSemanticReadiness(cwd, { kind: "file", file });
+  const readiness = await capability.ensureSemanticReadiness(cwd, { kind: "file", file }, control);
   if (readiness.kind === "ready") return null;
   if (readiness.kind === "timeout") {
     return "Semantic readiness timed out. Retry shortly or inspect code_health.";

package/src/session/health-refresh.ts

@@ -0,0 +1,175 @@
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { WorkspaceDiagnosticReport, WorkspaceLspRuntime } from "@mrclrchtr/supi-lsp/api";
+import { recoverDiagnosticRuntime } from "../analysis/health/recovery.ts";
+import { mergeDiagnosticEvidence } from "../diagnostics/evidence.ts";
+import { refreshFileLspMaintenance, refreshLspMaintenance } from "../substrate/lsp/maintenance.ts";
+import type { HealthDiagnosticScope, HealthRefreshAttempt } from "./health-types.ts";
+
+interface HealthRefreshAttemptOptions {
+  readonly runtime: WorkspaceLspRuntime;
+  readonly diagnosticsScope: HealthDiagnosticScope;
+  readonly attemptedAt: number;
+  readonly cwd: string;
+  readonly sentinelSnapshot: Map<string, number>;
+  readonly control?: CodeRequestControl;
+  readonly reportRecoveryProgress?: () => void;
+}
+
+export interface HealthRefreshCollection {
+  readonly attempt: HealthRefreshAttempt;
+  /** Final report from the runtime, retained only for the current workflow. */
+  readonly diagnosticReport?: WorkspaceDiagnosticReport;
+}
+
+/** Run one file- or workspace-scoped health refresh attempt. */
+export async function collectHealthRefreshAttempt(
+  options: HealthRefreshAttemptOptions,
+): Promise<HealthRefreshCollection> {
+  if (options.diagnosticsScope.kind === "file") {
+    return collectFileRefreshAttempt(options, options.diagnosticsScope);
+  }
+  return collectWorkspaceRefreshAttempt(options);
+}
+
+async function collectFileRefreshAttempt(
+  options: HealthRefreshAttemptOptions,
+  scope: Extract<HealthDiagnosticScope, { kind: "file" }>,
+): Promise<HealthRefreshCollection> {
+  const maintenance = await refreshFileLspMaintenance({
+    runtime: options.runtime,
+    cwd: options.cwd,
+    sentinelSnapshot: options.sentinelSnapshot,
+    filePath: scope.path,
+    control: options.control,
+  });
+  updateSentinelSnapshot(options.sentinelSnapshot, maintenance.snapshot);
+  const readiness = await options.runtime.waitUntilReadyForFile(
+    scope.path,
+    undefined,
+    options.control,
+  );
+  return {
+    attempt: {
+      kind: "completed",
+      attemptedAt: options.attemptedAt,
+      elapsedMs: Date.now() - options.attemptedAt,
+      requestedDiagnosticScope: scope,
+      operationScope: "file-runtime",
+      attemptedActiveClients: readiness.kind === "ready" ? 1 : 0,
+      restartedClients: 0,
+      staleAssessment: {
+        scope: "file",
+        suspected: null,
+        matchedFileCount: maintenance.matchedStaleFileCount,
+        warning: null,
+      },
+    },
+  };
+}
+
+async function collectWorkspaceRefreshAttempt(
+  options: HealthRefreshAttemptOptions,
+): Promise<HealthRefreshCollection> {
+  const workspaceScope =
+    options.diagnosticsScope.kind === "tracked-files" ? options.diagnosticsScope : null;
+  const maintenance = await refreshLspMaintenance(
+    options.runtime,
+    options.cwd,
+    options.sentinelSnapshot,
+    {
+      control: options.control,
+      scope: workspaceScope?.filter ?? null,
+      trackSources: workspaceScope !== null,
+    },
+  );
+  updateSentinelSnapshot(options.sentinelSnapshot, maintenance.snapshot);
+  if (maintenance.failureReason) {
+    return {
+      attempt: {
+        kind: "failed",
+        attemptedAt: options.attemptedAt,
+        elapsedMs: Date.now() - options.attemptedAt,
+        requestedDiagnosticScope: options.diagnosticsScope,
+        operationScope: "workspace-runtime",
+        diagnosticEvidence: maintenance.diagnosticEvidence,
+        reason: maintenance.failureReason,
+      },
+    };
+  }
+
+  try {
+    const recovery = await recoverDiagnosticRuntime({
+      service: options.runtime,
+      control: options.control,
+      progress: options.reportRecoveryProgress,
+      // The maintenance pass already refreshed every open document; reuse its
+      // evidence so the recovery pass skips a redundant second refresh.
+      initialEvidence: maintenance.diagnosticEvidence,
+    });
+    const diagnosticEvidence = mergeDiagnosticEvidence(
+      maintenance.diagnosticEvidence,
+      recovery.diagnosticEvidence,
+      options.cwd,
+    );
+    if (recovery.refreshFailureReason) {
+      return {
+        attempt: {
+          kind: "failed",
+          attemptedAt: options.attemptedAt,
+          elapsedMs: Date.now() - options.attemptedAt,
+          requestedDiagnosticScope: options.diagnosticsScope,
+          operationScope: "workspace-runtime",
+          diagnosticEvidence,
+          reason: recovery.refreshFailureReason,
+        },
+        diagnosticReport: recovery.diagnosticReport,
+      };
+    }
+    return {
+      attempt: {
+        kind: "completed",
+        attemptedAt: options.attemptedAt,
+        elapsedMs: Date.now() - options.attemptedAt,
+        requestedDiagnosticScope: options.diagnosticsScope,
+        operationScope: "workspace-runtime",
+        attemptedActiveClients: recovery.attemptedClients,
+        restartedClients: recovery.restartedClients,
+        diagnosticEvidence,
+        staleAssessment: {
+          scope: "workspace",
+          suspected: recovery.staleAssessment.suspected,
+          matchedFileCount: recovery.staleAssessment.matchedFiles.length,
+          warning: recovery.staleAssessment.warning,
+        },
+      },
+      diagnosticReport: recovery.diagnosticReport,
+    };
+  } catch (error) {
+    // Cancellation must propagate; a cancelled caller no longer awaits a
+    // recorded failed attempt.
+    if (isCodeRequestInterruption(error, options.control)) throw error;
+    return {
+      attempt: {
+        kind: "failed",
+        attemptedAt: options.attemptedAt,
+        elapsedMs: Date.now() - options.attemptedAt,
+        requestedDiagnosticScope: options.diagnosticsScope,
+        operationScope: "workspace-runtime",
+        diagnosticEvidence: maintenance.diagnosticEvidence,
+        reason: errorMessage(error),
+      },
+    };
+  }
+}
+
+function updateSentinelSnapshot(target: Map<string, number>, next: Map<string, number>): void {
+  target.clear();
+  for (const [key, value] of next) target.set(key, value);
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error && error.message ? error.message : "Diagnostic refresh failed.";
+}

package/src/session/health-types.ts

@@ -1,3 +1,4 @@
+import type { DiagnosticEvidenceSummary, FileScopeDecision } from "@mrclrchtr/supi-lsp/api";
 import type { CapabilityWarningReport } from "../analysis/capability/capability-warnings.ts";
 
 export type HealthSection = "diagnostics" | "servers";
@@ -53,46 +54,73 @@ export type HealthDiagnosticObservation =
       readonly kind: "completed";
       readonly scope: HealthDiagnosticScope;
       readonly entries: readonly HealthDiagnosticEntry[];
+      readonly evidence: DiagnosticEvidenceSummary;
+      /** Tsconfig scope decision for the requested file (file scope only). */
+      readonly scopeStatus?: FileScopeDecision;
     }
   | {
       readonly kind: "partial";
       readonly scope: HealthDiagnosticScope;
       readonly entries: readonly HealthDiagnosticEntry[];
+      readonly evidence: DiagnosticEvidenceSummary;
       readonly reason: string;
+      /** Tsconfig scope decision for the requested file (file scope only). */
+      readonly scopeStatus?: FileScopeDecision;
     }
   | {
       readonly kind: "unavailable";
       readonly scope: HealthDiagnosticScope;
       readonly entries: readonly HealthDiagnosticEntry[];
+      readonly evidence: DiagnosticEvidenceSummary;
       readonly reason: string;
+      /** Tsconfig scope decision for the requested file (file scope only). */
+      readonly scopeStatus?: FileScopeDecision;
     };
 
-/** Bounded stale-diagnostic metadata from a completed workspace recovery pass. */
+/** Bounded stale-diagnostic metadata from one refresh attempt. */
 export interface HealthStaleAssessment {
-  readonly suspected: boolean;
+  readonly scope: "file" | "workspace";
+  readonly suspected: boolean | null;
   readonly matchedFileCount: number;
   readonly warning: string | null;
 }
 
-/** A diagnostic refresh attempt against the workspace LSP runtime. */
+export type HealthRefreshOperationScope = "file-runtime" | "workspace-runtime";
+
+/** Shared facts for one completed refresh or file-maintenance attempt. */
+interface CompletedHealthRefreshAttempt {
+  readonly kind: "completed";
+  readonly attemptedAt: number;
+  /** Wall-clock duration of the attempt, for telemetry. */
+  readonly elapsedMs: number;
+  /** The diagnostic evidence scope requested by the caller, not the runtime operation scope. */
+  readonly requestedDiagnosticScope: HealthDiagnosticScope;
+  /** Active clients targeted by the best-effort operation; this is not a confirmed-success count. */
+  readonly attemptedActiveClients: number;
+  readonly restartedClients: number;
+  readonly staleAssessment: HealthStaleAssessment;
+}
+
+/** A diagnostic refresh attempt against an explicit LSP runtime scope. */
 export type HealthRefreshAttempt =
-  | {
-      readonly kind: "completed";
-      readonly attemptedAt: number;
-      /** The diagnostic evidence scope requested by the caller, not the runtime operation scope. */
-      readonly requestedDiagnosticScope: HealthDiagnosticScope;
-      /** Recovery always operates against the workspace runtime. */
+  | (CompletedHealthRefreshAttempt & {
       readonly operationScope: "workspace-runtime";
-      /** Active clients targeted by the best-effort refresh; this is not a confirmed-success count. */
-      readonly attemptedActiveClients: number;
-      readonly restartedClients: number;
-      readonly staleAssessment: HealthStaleAssessment;
-    }
+      /** Final document-level evidence from the refresh or recovery pass. */
+      readonly diagnosticEvidence: DiagnosticEvidenceSummary;
+    })
+  | (CompletedHealthRefreshAttempt & {
+      /** File maintenance does not claim a workspace diagnostic refresh. */
+      readonly operationScope: "file-runtime";
+    })
   | {
       readonly kind: "failed";
       readonly attemptedAt: number;
+      /** Wall-clock duration of the attempt, for telemetry. */
+      readonly elapsedMs: number;
       readonly requestedDiagnosticScope: HealthDiagnosticScope;
-      readonly operationScope: "workspace-runtime";
+      readonly operationScope: HealthRefreshOperationScope;
+      /** Evidence collected before the operation failed, when available. */
+      readonly diagnosticEvidence?: DiagnosticEvidenceSummary;
       readonly reason: string;
     };
 

package/src/session/health-workflow.ts

@@ -1,8 +1,10 @@
 /** Session-owned workspace health workflow. */
 
 import type { CapabilityState } from "@mrclrchtr/supi-code-runtime/api";
+import { isCodeRequestInterruption } from "@mrclrchtr/supi-code-runtime/api";
 import type {
   LspRuntimeController,
+  WorkspaceDiagnosticReport,
   WorkspaceLspRuntime,
   WorkspaceLspRuntimeState,
 } from "@mrclrchtr/supi-lsp/api";
@@ -15,11 +17,12 @@ import {
   diagnosticScope,
   isScopedFile,
 } from "../analysis/health/diagnostics.ts";
-import { describeStructuralState, recoverDiagnosticRuntime } from "../analysis/health/recovery.ts";
+import { describeStructuralState } from "../analysis/health/recovery.ts";
 import { collectServers } from "../analysis/health/signals.ts";
+import { SEMANTIC_READINESS_TIMEOUT_REASON } from "../analysis/readiness.ts";
 import { resolveScope } from "../analysis/search/paths.ts";
-import { refreshLspMaintenance } from "../substrate/lsp/maintenance.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
+import { collectHealthRefreshAttempt } from "./health-refresh.ts";
 import type {
   HealthData,
   HealthDiagnosticScope,
@@ -63,14 +66,15 @@ export async function runHealthWorkflow(
     phase: "collection",
     message: "Collecting workspace health evidence",
   });
-
   const lspState = deps.capability.getLspRuntimeState(deps.cwd);
   const capabilityStates = deps.capability.getCapabilityStates(deps.cwd);
   const runtime = lspState.kind === "ready" ? lspState.runtime : null;
+  const evidenceRuntime =
+    lspState.kind === "ready" || lspState.kind === "inactive" ? lspState.runtime : null;
   const serverInventoryAvailable = lspState.kind === "ready" || lspState.kind === "disabled";
 
   const diagnosticsScope = diagnosticScope(scopeFilter);
-  const refresh = await collectRefreshState({
+  const refreshCollection = await collectRefreshState({
     refreshRequested: request.refresh === true,
     diagnosticsRequested: included.includes("diagnostics"),
     runtime,
@@ -85,18 +89,31 @@ export async function runHealthWorkflow(
     scopeFilter,
     lspState,
     capabilityState: capabilityStates.semantic,
+    control,
   });
   const semanticReady = semanticState?.kind === "ready";
   throwIfAborted(control);
 
   const diagnostics = await collectDiagnostics({
     service: semanticReady ? runtime : null,
+    evidenceService: evidenceRuntime,
     included,
     scope: diagnosticsScope,
     cwd: deps.cwd,
     unavailableReason: diagnosticUnavailableReason(semanticState),
     detailed: level === "detailed",
+    requestControl: control,
+    refreshEvidence:
+      (refreshCollection.attempt.kind === "completed" ||
+        refreshCollection.attempt.kind === "failed") &&
+      refreshCollection.attempt.operationScope === "workspace-runtime"
+        ? refreshCollection.attempt.diagnosticEvidence
+        : undefined,
+    refreshReport: refreshCollection.diagnosticReport,
   });
+  // A cancellation that landed during diagnostic resolution must not produce
+  // a completed health result the caller no longer awaits.
+  throwIfAborted(control);
   const servers = collectServers(runtime, included);
   const capabilityWarnings = collectCapabilityWarnings(semanticRequested, deps);
 
@@ -108,14 +125,14 @@ export async function runHealthWorkflow(
     structuralStatus: describeStructuralState(capabilityStates.structural),
     diagnostics,
     servers,
-    refresh,
+    refresh: refreshCollection.attempt,
     level,
     capabilityWarnings: capabilityWarnings?.hasWarnings ? capabilityWarnings : undefined,
   };
 
+  throwIfAborted(control);
   return { kind: "completed", data };
 }
-
 function healthNeedsSemantic(included: readonly HealthSection[]): boolean {
   return included.includes("diagnostics") || included.includes("servers");
 }
@@ -126,6 +143,7 @@ interface SemanticHealthStateOptions {
   scopeFilter: string | null;
   lspState: WorkspaceLspRuntimeState;
   capabilityState: CapabilityState;
+  control?: WorkflowControl;
 }
 
 async function establishSemanticHealthState(
@@ -133,10 +151,14 @@ async function establishSemanticHealthState(
 ): Promise<SemanticHealthState | null> {
   if (!options.requested) return null;
   if (options.runtime && isScopedFile(options.scopeFilter)) {
-    const readiness = await options.runtime.waitUntilReadyForFile(options.scopeFilter);
+    const readiness = await options.runtime.waitUntilReadyForFile(
+      options.scopeFilter,
+      undefined,
+      options.control,
+    );
     if (readiness.kind === "ready") return { kind: "ready" };
     if (readiness.kind === "timeout") {
-      return { kind: "pending", reason: "File semantic readiness timed out" };
+      return { kind: "pending", reason: SEMANTIC_READINESS_TIMEOUT_REASON };
     }
     return { kind: "unavailable", reason: readiness.reason };
   }
@@ -195,6 +217,11 @@ function collectCapabilityWarnings(
   return report.hasWarnings ? report : undefined;
 }
 
+interface HealthRefreshStateCollection {
+  readonly attempt: HealthRefreshState;
+  readonly diagnosticReport?: WorkspaceDiagnosticReport;
+}
+
 interface RefreshStateOptions {
   readonly refreshRequested: boolean;
   readonly diagnosticsRequested: boolean;
@@ -206,91 +233,79 @@ interface RefreshStateOptions {
 }
 
 /** Run the requested workspace-runtime refresh and retain only facts the runtime establishes. */
-async function collectRefreshState(options: RefreshStateOptions): Promise<HealthRefreshState> {
+async function collectRefreshState(
+  options: RefreshStateOptions,
+): Promise<HealthRefreshStateCollection> {
   const { deps, diagnosticsRequested, diagnosticsScope, lspState, runtime } = options;
   if (!diagnosticsRequested) {
     return {
-      kind: "not-requested",
-      reason: "Diagnostics were not requested.",
-      lastAttempt: deps.lastRefreshAttempt,
+      attempt: {
+        kind: "not-requested",
+        reason: "Diagnostics were not requested.",
+        lastAttempt: deps.lastRefreshAttempt,
+      },
     };
   }
   if (!options.refreshRequested) {
     return {
-      kind: "not-requested",
-      reason: "Refresh was not requested.",
-      lastAttempt: deps.lastRefreshAttempt,
+      attempt: {
+        kind: "not-requested",
+        reason: "Refresh was not requested.",
+        lastAttempt: deps.lastRefreshAttempt,
+      },
     };
   }
   if (!runtime) {
     return {
-      kind: "not-attempted",
-      reason: refreshUnavailableReason(lspState),
-      lastAttempt: deps.lastRefreshAttempt,
+      attempt: {
+        kind: "not-attempted",
+        reason: refreshUnavailableReason(lspState),
+        lastAttempt: deps.lastRefreshAttempt,
+      },
     };
   }
 
   const attemptedAt = Date.now();
+  const operationScope = diagnosticsScope.kind === "file" ? "file-runtime" : "workspace-runtime";
   try {
     reportProgress(options.control, {
       intent: "health",
       phase: "maintenance",
       message: "Refreshing LSP state and sentinel snapshot",
     });
-    updateSentinelSnapshot(
-      deps.sentinelSnapshot,
-      await refreshLspMaintenance(runtime, deps.cwd, deps.sentinelSnapshot),
-    );
-    if (diagnosticsScope.kind === "file") {
-      try {
-        await runtime.waitUntilReadyForFile(diagnosticsScope.path);
-      } catch {
-        // Recovery still gets a chance to restart a failed routed client.
-      }
-    }
-
-    const recovery = await recoverDiagnosticRuntime({
-      service: runtime,
-      progress: () =>
+    const attempt = await collectHealthRefreshAttempt({
+      runtime,
+      diagnosticsScope,
+      attemptedAt,
+      cwd: options.deps.cwd,
+      sentinelSnapshot: options.deps.sentinelSnapshot,
+      control: options.control,
+      reportRecoveryProgress: () =>
         reportProgress(options.control, {
           intent: "health",
           phase: "recovery",
           message: "Refreshing diagnostics and recovery state",
         }),
     });
-    const attempt: HealthRefreshAttempt = {
-      kind: "completed",
-      attemptedAt,
-      requestedDiagnosticScope: diagnosticsScope,
-      operationScope: "workspace-runtime",
-      attemptedActiveClients: recovery.attemptedClients,
-      restartedClients: recovery.restartedClients,
-      staleAssessment: {
-        suspected: recovery.staleAssessment.suspected,
-        matchedFileCount: recovery.staleAssessment.matchedFiles.length,
-        warning: recovery.staleAssessment.warning,
-      },
-    };
-    deps.trackRefreshAttempt(attempt);
+    deps.trackRefreshAttempt(attempt.attempt);
     return attempt;
   } catch (error) {
+    // Cancellation must propagate; a cancelled caller no longer awaits a
+    // recorded failed attempt or the refresh data it would carry.
+    if (isCodeRequestInterruption(error, options.control)) throw error;
     const attempt: HealthRefreshAttempt = {
       kind: "failed",
       attemptedAt,
+      elapsedMs: Date.now() - attemptedAt,
       requestedDiagnosticScope: diagnosticsScope,
-      operationScope: "workspace-runtime",
+      operationScope,
       reason: errorMessage(error),
     };
     deps.trackRefreshAttempt(attempt);
-    return attempt;
+    return { attempt };
   }
 }
 
-function updateSentinelSnapshot(target: Map<string, number>, next: Map<string, number>): void {
-  target.clear();
-  for (const [key, value] of next) target.set(key, value);
-}
-
 function refreshUnavailableReason(lspState: WorkspaceLspRuntimeState): string {
   switch (lspState.kind) {
     case "unavailable":

package/src/session/input/workflows.ts

@@ -1,7 +1,7 @@
 /** Runtime parsers for inspection, Orientation, graph, and find workflows. */
 
-import { type CodeFindAstKind, isCodeFindAstKind } from "../../tool/find/ast-kinds.ts";
-import { CODE_FIND_MODES } from "../../tool/find/modes.ts";
+import { type CodeFindAstKind, isCodeFindAstKind } from "../../tool/code_find/ast-kinds.ts";
+import { CODE_FIND_MODES } from "../../tool/code_find/modes.ts";
 import type { FindMode, FindWorkflowInput } from "../find-types.ts";
 import type { GraphWorkflowInput, RequestedGraphRelation } from "../graph-types.ts";
 import type { InspectWorkflowInput } from "../inspect-types.ts";