@mrclrchtr/supi-code-intelligence 4.9.0 → 5.0.0

package/src/session/find-workflow.ts

@@ -30,7 +30,8 @@ export async function runFindWorkflow(
   const scope = resolveScopeSet(request.scope ? [...request.scope] : undefined, deps.cwd);
   if (scope.kind === "error") return { kind: "invalid-input", message: scope.reason };
 
-  throwIfAborted(control);
+  if (mode === "ast") control?.signal?.throwIfAborted();
+  else throwIfAborted(control);
   reportProgress(control, {
     intent: "find",
     phase: mode,
@@ -69,9 +70,11 @@ async function runSemanticSearch(options: {
   control?: WorkflowControl;
 }): Promise<FindWorkflowOutcome> {
   const { query, scopePaths, scopeLabel, maxResults, deps, control } = options;
-  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-    kind: "workspace",
-  });
+  const readiness = await deps.capability.ensureSemanticReadiness(
+    deps.cwd,
+    { kind: "workspace" },
+    control,
+  );
   if (readiness.kind === "timeout") {
     return { kind: "unavailable", reason: "Semantic readiness timed out." };
   }
@@ -82,7 +85,10 @@ async function runSemanticSearch(options: {
   if (!provider?.workspaceSymbols) {
     return { kind: "unavailable", reason: "No semantic workspace-symbol provider is active." };
   }
-  const result = await provider.workspaceSymbols(query);
+  const result = await provider.workspaceSymbols(query, control);
+  // A cancellation that landed during the request must not publish symbols
+  // the caller no longer awaits.
+  throwIfAborted(control);
   if (result.kind === "unavailable") {
     return { kind: "unavailable", reason: result.reason };
   }
@@ -120,13 +126,17 @@ async function runAstSearch(options: {
   if (!provider) {
     return { kind: "unavailable", reason: "No structural provider is active." };
   }
-  throwIfAborted(control);
+  control?.signal?.throwIfAborted();
   const outcome = await getStructuredPatternMatches({
     params: { pattern: query, kind: input.kind },
     roots: scopePaths,
     cwd: deps.cwd,
     structural: provider,
-    control: { signal: control?.signal },
+    control: {
+      operationId: control?.operationId,
+      signal: control?.signal,
+      deadline: control?.deadline,
+    },
   });
   if (outcome.kind === "invalid-input") return outcome;
   if (outcome.kind === "unavailable") return outcome;

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,148 @@
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { 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;
+}
+
+/** Run one file- or workspace-scoped health refresh attempt. */
+export async function collectHealthRefreshAttempt(
+  options: HealthRefreshAttemptOptions,
+): Promise<HealthRefreshAttempt> {
+  if (options.diagnosticsScope.kind === "file") {
+    return collectFileRefreshAttempt(options, options.diagnosticsScope);
+  }
+  return collectWorkspaceRefreshAttempt(options);
+}
+
+async function collectFileRefreshAttempt(
+  options: HealthRefreshAttemptOptions,
+  scope: Extract<HealthDiagnosticScope, { kind: "file" }>,
+): Promise<Extract<HealthRefreshAttempt, { kind: "completed" }>> {
+  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 {
+    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<HealthRefreshAttempt> {
+  const maintenance = await refreshLspMaintenance(
+    options.runtime,
+    options.cwd,
+    options.sentinelSnapshot,
+    options.control,
+  );
+  updateSentinelSnapshot(options.sentinelSnapshot, maintenance.snapshot);
+  if (maintenance.failureReason) {
+    return {
+      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,
+    });
+    const diagnosticEvidence = mergeDiagnosticEvidence(
+      maintenance.diagnosticEvidence,
+      recovery.diagnosticEvidence,
+      options.cwd,
+    );
+    if (recovery.refreshFailureReason) {
+      return {
+        kind: "failed",
+        attemptedAt: options.attemptedAt,
+        elapsedMs: Date.now() - options.attemptedAt,
+        requestedDiagnosticScope: options.diagnosticsScope,
+        operationScope: "workspace-runtime",
+        diagnosticEvidence,
+        reason: recovery.refreshFailureReason,
+      };
+    }
+    return {
+      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,
+      },
+    };
+  } catch (error) {
+    // Cancellation must propagate; a cancelled caller no longer awaits a
+    // recorded failed attempt.
+    if (isCodeRequestInterruption(error, options.control)) throw error;
+    return {
+      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 } from "@mrclrchtr/supi-lsp/api";
 import type { CapabilityWarningReport } from "../analysis/capability/capability-warnings.ts";
 
 export type HealthSection = "diagnostics" | "servers";
@@ -53,46 +54,67 @@ export type HealthDiagnosticObservation =
       readonly kind: "completed";
       readonly scope: HealthDiagnosticScope;
       readonly entries: readonly HealthDiagnosticEntry[];
+      readonly evidence: DiagnosticEvidenceSummary;
     }
   | {
       readonly kind: "partial";
       readonly scope: HealthDiagnosticScope;
       readonly entries: readonly HealthDiagnosticEntry[];
+      readonly evidence: DiagnosticEvidenceSummary;
       readonly reason: string;
     }
   | {
       readonly kind: "unavailable";
       readonly scope: HealthDiagnosticScope;
       readonly entries: readonly HealthDiagnosticEntry[];
+      readonly evidence: DiagnosticEvidenceSummary;
       readonly reason: string;
     };
 
-/** 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,6 +1,7 @@
 /** 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,
   WorkspaceLspRuntime,
@@ -15,11 +16,11 @@ 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 { 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,10 +64,11 @@ 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);
@@ -85,18 +87,29 @@ 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:
+      (refresh.kind === "completed" || refresh.kind === "failed") &&
+      refresh.operationScope === "workspace-runtime"
+        ? refresh.diagnosticEvidence
+        : undefined,
   });
+  // 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);
 
@@ -113,9 +126,9 @@ export async function runHealthWorkflow(
     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 +139,7 @@ interface SemanticHealthStateOptions {
   scopeFilter: string | null;
   lspState: WorkspaceLspRuntimeState;
   capabilityState: CapabilityState;
+  control?: WorkflowControl;
 }
 
 async function establishSemanticHealthState(
@@ -133,7 +147,11 @@ 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" };
@@ -231,54 +249,39 @@ async function collectRefreshState(options: RefreshStateOptions): Promise<Health
   }
 
   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);
     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);
@@ -286,11 +289,6 @@ async function collectRefreshState(options: RefreshStateOptions): Promise<Health
   }
 }
 
-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/inspect/collect.ts

@@ -2,6 +2,8 @@
 
 import {
   type CodePosition,
+  type CodeRequestControl,
+  isCodeRequestInterruption,
   mapCodeQueryResult,
   type OutlineData,
   type SemanticProvider,
@@ -27,6 +29,7 @@ export interface InspectCollectionInput {
   readonly line: number;
   readonly character: number;
   readonly lineCount: number;
+  readonly requestControl?: CodeRequestControl;
   readonly structural: StructuralProvider | null;
   readonly semantic: SemanticProvider | null;
   readonly semanticUnavailableReason: string;
@@ -50,7 +53,12 @@ async function collectNode(
 ): Promise<InspectObservation<InspectNode | null>> {
   if (!input.structural) return unavailableCodeQuery("No structural node provider is active.");
   try {
-    const result = await input.structural.nodeAt(input.file, input.line, input.character);
+    const result = await input.structural.nodeAt(
+      input.file,
+      input.line,
+      input.character,
+      input.requestControl,
+    );
     if (result.kind !== "success") return unavailableCodeQuery(result.message);
     return {
       kind: "completed",
@@ -65,6 +73,7 @@ async function collectNode(
       },
     };
   } catch (error) {
+    if (isCodeRequestInterruption(error, input.requestControl)) throw error;
     return unavailableCodeQuery(failureReason("Structural node lookup", error));
   }
 }
@@ -74,7 +83,7 @@ async function collectEnclosingSymbol(
 ): Promise<InspectObservation<InspectEnclosingSymbol | null>> {
   if (!input.structural) return unavailableCodeQuery("No structural outline provider is active.");
   try {
-    const result = await input.structural.outline(input.file);
+    const result = await input.structural.outline(input.file, input.requestControl);
     if (result.kind !== "success") return unavailableCodeQuery(result.message);
     return {
       kind: "completed",
@@ -84,6 +93,7 @@ async function collectEnclosingSymbol(
       }),
     };
   } catch (error) {
+    if (isCodeRequestInterruption(error, input.requestControl)) throw error;
     return unavailableCodeQuery(failureReason("Structural outline lookup", error));
   }
 }
@@ -98,6 +108,7 @@ async function collectHover(
       (hover) => hover?.contents ?? null,
     );
   } catch (error) {
+    if (isCodeRequestInterruption(error, input.requestControl)) throw error;
     return unavailableCodeQuery(failureReason("Hover lookup", error));
   }
 }
@@ -131,6 +142,7 @@ async function collectDefinition(
       ? { kind: "partial", data: definitions, reason: reasons.join(" ") }
       : { kind: "completed", data: definitions };
   } catch (error) {
+    if (isCodeRequestInterruption(error, input.requestControl)) throw error;
     return unavailableCodeQuery(failureReason("Definition lookup", error));
   }
 }
@@ -142,7 +154,11 @@ async function collectDiagnostics(
     return unavailableCodeQuery(lspUnavailableReason(input.lspState));
   }
   try {
-    const result = await input.lspState.runtime.fileDiagnostics(input.file, 4);
+    const result = await input.lspState.runtime.fileDiagnostics(
+      input.file,
+      4,
+      input.requestControl,
+    );
     if (result.kind === "unavailable") return result;
     const diagnostics = result.data
       .filter((diagnostic) => diagnosticOverlapsWindow(diagnostic.range, input))
@@ -159,6 +175,7 @@ async function collectDiagnostics(
       ? { kind: "partial", data: diagnostics, reason: result.reason }
       : { kind: "completed", data: diagnostics };
   } catch (error) {
+    if (isCodeRequestInterruption(error, input.requestControl)) throw error;
     return unavailableCodeQuery(failureReason("Diagnostic lookup", error));
   }
 }