@mrclrchtr/supi-code-intelligence 4.10.0 → 5.0.0

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));
   }
 }

package/src/session/inspect-workflow.ts

@@ -1,6 +1,7 @@
 /** Session-owned point inspection workflow. */
 
 import type { WorkspaceLspRuntimeState } from "@mrclrchtr/supi-lsp/api";
+import { withSemanticRequestControl } from "../analysis/provider.ts";
 import type { CapabilityAdapter, ReadinessOutcome } from "./capability-adapter.ts";
 import { parseInspectWorkflowInput } from "./input/workflows.ts";
 import { collectInspectSections } from "./inspect/collect.ts";
@@ -37,14 +38,17 @@ export async function runInspectWorkflow(
     phase: "providers",
     message: "Collecting point facts",
   });
-  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-    kind: "file",
-    file: point.value.file,
-  });
+  const readiness = await deps.capability.ensureSemanticReadiness(
+    deps.cwd,
+    { kind: "file", file: point.value.file },
+    control,
+  );
   throwIfAborted(control);
 
   const semanticReady = readiness.kind === "ready";
-  const semantic = semanticReady ? deps.capability.getSemanticProvider(deps.cwd) : null;
+  const semantic = semanticReady
+    ? withSemanticRequestControl(deps.capability.getSemanticProvider(deps.cwd), control)
+    : null;
   const lspState = semanticReady
     ? deps.capability.getLspRuntimeState(deps.cwd)
     : unavailableLspState(readiness);
@@ -54,6 +58,7 @@ export async function runInspectWorkflow(
     line: point.value.line,
     character: point.value.character,
     lineCount: point.value.lineCount,
+    requestControl: control,
     structural: deps.capability.getStructuralProvider(deps.cwd),
     semantic,
     semanticUnavailableReason: semantic

package/src/session/orientation/collect.ts

@@ -2,6 +2,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import { isCodeRequestInterruption } from "@mrclrchtr/supi-code-runtime/api";
 import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type { Diagnostic } from "@mrclrchtr/supi-lsp/api";
 import {
@@ -69,6 +70,7 @@ async function executeOrientationContext(
     focus: input.focus,
     maxResults: input.maxResults ?? 10,
     lspRuntime: deps.lspRuntime,
+    requestControl: deps.requestControl,
   });
 }
 
@@ -262,6 +264,7 @@ async function collectDefinitionTargets(
       evidenceLists: [evidence.metadata],
     };
   } catch (error) {
+    if (isCodeRequestInterruption(error, deps.requestControl)) throw error;
     return {
       items: [],
       hasSemanticEvidence: false,
@@ -295,7 +298,11 @@ async function buildDiagnosticsSection(
 
   try {
     const targetFile = path.resolve(deps.cwd, target.file);
-    const result = await deps.lspRuntime.runtime.fileDiagnostics(targetFile, 4);
+    const result = await deps.lspRuntime.runtime.fileDiagnostics(
+      targetFile,
+      4,
+      deps.requestControl,
+    );
     if (result.kind === "unavailable") {
       return unavailableTargetSection(
         [{ kind: "paragraph", text: `Diagnostics unavailable for this target — ${result.reason}` }],
@@ -331,6 +338,7 @@ async function buildDiagnosticsSection(
       evidenceLists: [evidence.metadata],
     };
   } catch (error) {
+    if (isCodeRequestInterruption(error, deps.requestControl)) throw error;
     return unavailableTargetSection(
       [{ kind: "paragraph", text: "Diagnostics failed to load." }],
       false,
@@ -492,6 +500,7 @@ async function maybeGatherTreeContext(
     target.displayLine,
     target.displayCharacter,
     target.anchorKind !== "declaration",
+    deps.requestControl,
   );
 }
 

package/src/session/orientation/context-facts.ts

@@ -1,5 +1,6 @@
 import { statSync } from "node:fs";
 import * as path from "node:path";
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import type { WorkspaceLspRuntimeState } from "@mrclrchtr/supi-lsp/api";
 import type {
   ArchitectureModel,
@@ -32,6 +33,7 @@ interface ContextFactsInput {
   readonly maxResults: number;
   readonly provider: CodeProvider | null;
   readonly lspRuntime: WorkspaceLspRuntimeState;
+  readonly requestControl?: CodeRequestControl;
 }
 
 /** Collect direct filesystem, parsed-manifest, and explicit-provider Orientation facts. */
@@ -115,7 +117,7 @@ async function collectFileFacts(
   });
   appendTopologyWarning(builder, input.model);
   appendPackageContext(builder, input.model, focus);
-  await appendStructuralFileFacts(builder, input.provider, focus);
+  await appendStructuralFileFacts(builder, input.provider, focus, input.requestControl);
   appendPrioritySignals(builder, {
     scope: focus,
     isFile: true,