@mrclrchtr/supi-code-intelligence 4.10.0 → 5.0.0

package/src/analysis/readiness.ts

@@ -1,4 +1,8 @@
-import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  type CodeRequestControl,
+  getDefaultWorkspaceRuntime,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
 import {
   getWorkspaceLspRuntime,
   type SemanticReadinessResult,
@@ -14,7 +18,10 @@ export async function ensureSemanticReadiness(
   cwd: string,
   scope: SemanticStartupScope,
   timeoutMs: number = DEFAULT_SEMANTIC_STARTUP_TIMEOUT_MS,
+  control?: CodeRequestControl,
 ): Promise<SemanticReadinessResult> {
+  // A cancelled caller stops before any readiness work starts.
+  throwIfCodeRequestInterrupted(control);
   const workspace = getDefaultWorkspaceRuntime().getWorkspace(cwd);
   if (workspace.semantic.provider === null) {
     return {
@@ -24,7 +31,7 @@ export async function ensureSemanticReadiness(
   }
 
   if (workspace.semantic.state.kind === "ready") {
-    return resolveReadySemanticState(cwd, scope, timeoutMs);
+    return resolveReadySemanticState(cwd, scope, timeoutMs, control);
   }
 
   if (workspace.semantic.state.kind !== "pending") {
@@ -34,13 +41,15 @@ export async function ensureSemanticReadiness(
     };
   }
 
-  const deadline = Date.now() + timeoutMs;
+  // The request deadline bounds the internal readiness budget when it is
+  // earlier than the relative startup timeout.
+  const deadline = Math.min(Date.now() + timeoutMs, control?.deadline ?? Infinity);
 
   const remainingAfterService = deadline - Date.now();
   if (remainingAfterService <= 0) {
     return { kind: "timeout" };
   }
-  const lspState = await resolveSemanticServiceState(cwd, remainingAfterService);
+  const lspState = await resolveSemanticServiceState(cwd, remainingAfterService, control);
   if (lspState.kind === "pending") {
     return { kind: "timeout" };
   }
@@ -58,8 +67,13 @@ export async function ensureSemanticReadiness(
   if (remainingAfterLsp <= 0) {
     return { kind: "timeout" };
   }
-  return scope.kind === "workspace"
-    ? lspState.runtime.waitUntilReadyForWorkspace({ timeoutMs: remainingAfterLsp })
+  if (scope.kind === "workspace") {
+    return control
+      ? lspState.runtime.waitUntilReadyForWorkspace({ timeoutMs: remainingAfterLsp }, control)
+      : lspState.runtime.waitUntilReadyForWorkspace({ timeoutMs: remainingAfterLsp });
+  }
+  return control
+    ? lspState.runtime.waitUntilReadyForFile(scope.file, { timeoutMs: remainingAfterLsp }, control)
     : lspState.runtime.waitUntilReadyForFile(scope.file, { timeoutMs: remainingAfterLsp });
 }
 
@@ -67,11 +81,17 @@ function resolveReadySemanticState(
   cwd: string,
   scope: SemanticStartupScope,
   timeoutMs: number,
+  control?: CodeRequestControl,
 ): Promise<SemanticReadinessResult> | SemanticReadinessResult {
   const lspState = getWorkspaceLspRuntime(cwd);
   if (lspState.kind === "ready") {
-    return scope.kind === "workspace"
-      ? lspState.runtime.waitUntilReadyForWorkspace({ timeoutMs })
+    if (scope.kind === "workspace") {
+      return control
+        ? lspState.runtime.waitUntilReadyForWorkspace({ timeoutMs }, control)
+        : lspState.runtime.waitUntilReadyForWorkspace({ timeoutMs });
+    }
+    return control
+      ? lspState.runtime.waitUntilReadyForFile(scope.file, { timeoutMs }, control)
       : lspState.runtime.waitUntilReadyForFile(scope.file, { timeoutMs });
   }
   return {
@@ -86,8 +106,9 @@ function resolveReadySemanticState(
 async function resolveSemanticServiceState(
   cwd: string,
   timeoutMs: number,
+  control?: CodeRequestControl,
 ): Promise<WorkspaceLspRuntimeState> {
   const initialState = getWorkspaceLspRuntime(cwd);
   if (initialState.kind !== "pending") return initialState;
-  return waitForWorkspaceLspRuntime(cwd, timeoutMs);
+  return waitForWorkspaceLspRuntime(cwd, timeoutMs, control);
 }

package/src/analysis/refactor/apply.ts

@@ -16,6 +16,7 @@ import { readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:
 import { basename, dirname, join } from "node:path";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import type { FileEdit, WorkspaceEdit } from "@mrclrchtr/supi-code-runtime/api";
+import { revalidateMutationAuthority } from "./mutation-authority.ts";
 import { compareCodePositions, createLogicalLineIndex } from "./position.ts";
 import { validateEditAgainstFiles } from "./safety.ts";
 
@@ -24,8 +25,12 @@ export type ApplyResult =
   | { kind: "error"; reason: string };
 
 export interface ApplyOptions {
+  /** Canonical roots authorized by the semantic provider that made the plan. */
+  authorizedMutationRoots: readonly string[];
   /** Expected SHA-256 fingerprints per file, validated after queue acquisition. */
   expectedFingerprints?: ReadonlyMap<string, string>;
+  /** Current LSP document version, or null when the document is not open. */
+  getOpenDocumentVersion?: (file: string) => number | null;
 }
 
 /**
@@ -49,16 +54,24 @@ export interface ApplyOptions {
  */
 export async function applyWorkspaceEdit(
   edit: WorkspaceEdit,
-  options: ApplyOptions = {},
+  options: ApplyOptions,
 ): Promise<ApplyResult> {
   const grouped = groupEditsByFile(edit.edits);
   const files = [...grouped.keys()].sort();
   return withAllMutationQueues(files, async () => {
+    const authority = revalidateMutationAuthority(files, options.authorizedMutationRoots);
+    if (authority.kind === "unavailable") {
+      return { kind: "error", reason: authority.reason };
+    }
+
     if (options.expectedFingerprints) {
       const freshness = validateFingerprints(files, options.expectedFingerprints);
       if (!freshness.ok) return { kind: "error", reason: freshness.reason };
     }
 
+    const documentState = validateDocumentPreconditions(edit, options.getOpenDocumentVersion);
+    if (!documentState.ok) return { kind: "error", reason: documentState.reason };
+
     const validation = validateEditAgainstFiles(edit);
     if (!validation.safe) {
       return { kind: "error", reason: validation.reason };
@@ -76,6 +89,37 @@ export async function applyWorkspaceEdit(
   });
 }
 
+function validateDocumentPreconditions(
+  edit: WorkspaceEdit,
+  getOpenDocumentVersion: ApplyOptions["getOpenDocumentVersion"],
+): { ok: true } | { ok: false; reason: string } {
+  const preconditions = edit.documentPreconditions ?? [];
+  if (preconditions.length === 0) return { ok: true };
+  if (!getOpenDocumentVersion) {
+    return {
+      ok: false,
+      reason: "Stored document preconditions cannot be revalidated.",
+    };
+  }
+
+  for (const precondition of preconditions) {
+    const currentVersion = getOpenDocumentVersion(precondition.file);
+    if (precondition.kind === "open-document-version" && currentVersion !== precondition.version) {
+      return {
+        ok: false,
+        reason: `File ${precondition.file} open document version has changed since the plan was generated.`,
+      };
+    }
+    if (precondition.kind === "disk-content" && currentVersion !== null) {
+      return {
+        ok: false,
+        reason: `File ${precondition.file} is now open and no longer uses disk content as its master.`,
+      };
+    }
+  }
+  return { ok: true };
+}
+
 function validateFingerprints(
   files: string[],
   expected: ReadonlyMap<string, string>,

package/src/analysis/refactor/mutation-authority.ts

@@ -0,0 +1,143 @@
+import { lstatSync, realpathSync, statSync } from "node:fs";
+import * as path from "node:path";
+
+export type MutationAuthorityResult =
+  | { kind: "authorized"; canonicalRoots: string[] }
+  | { kind: "unavailable"; reason: string };
+
+/**
+ * Establish canonical provider roots and verify that all mutation files are
+ * regular files inside at least one root.
+ */
+export function establishMutationAuthority(
+  files: readonly string[],
+  providerRoots: readonly string[],
+): MutationAuthorityResult {
+  const roots = canonicalizeProviderRoots(providerRoots);
+  if (roots.kind === "unavailable") return roots;
+
+  const fileValidation = validateFiles(files, roots.canonicalRoots);
+  return fileValidation.kind === "unavailable" ? fileValidation : roots;
+}
+
+/** Revalidate stored canonical roots and mutation files immediately before mutation. */
+export function revalidateMutationAuthority(
+  files: readonly string[],
+  canonicalRoots: readonly string[],
+): MutationAuthorityResult {
+  if (canonicalRoots.length === 0) {
+    return { kind: "unavailable", reason: "Mutation plan has no authorized provider root." };
+  }
+
+  for (const root of canonicalRoots) {
+    if (!path.isAbsolute(root) || path.normalize(root) !== root) {
+      return { kind: "unavailable", reason: `Stored mutation root "${root}" is not canonical.` };
+    }
+    try {
+      if (!lstatSync(root).isDirectory() || realpathSync(root) !== root) {
+        return { kind: "unavailable", reason: `Stored mutation root "${root}" has changed.` };
+      }
+    } catch {
+      return { kind: "unavailable", reason: `Stored mutation root "${root}" is unavailable.` };
+    }
+  }
+
+  return validateFiles(files, canonicalRoots);
+}
+
+function canonicalizeProviderRoots(providerRoots: readonly string[]): MutationAuthorityResult {
+  if (providerRoots.length === 0) {
+    return { kind: "unavailable", reason: "Semantic route did not authorize a mutation root." };
+  }
+
+  const canonicalRoots = new Set<string>();
+  for (const root of providerRoots) {
+    if (!path.isAbsolute(root)) {
+      return { kind: "unavailable", reason: `Mutation root "${root}" is not absolute.` };
+    }
+    try {
+      const canonicalRoot = realpathSync(root);
+      if (!statSync(canonicalRoot).isDirectory()) {
+        return {
+          kind: "unavailable",
+          reason: `Mutation root "${root}" is not a directory.`,
+        };
+      }
+      canonicalRoots.add(canonicalRoot);
+    } catch {
+      return {
+        kind: "unavailable",
+        reason: `Mutation root "${root}" cannot be resolved to a canonical directory.`,
+      };
+    }
+  }
+
+  return { kind: "authorized", canonicalRoots: [...canonicalRoots].sort() };
+}
+
+function validateFiles(
+  files: readonly string[],
+  canonicalRoots: readonly string[],
+): MutationAuthorityResult {
+  for (const file of new Set(files)) {
+    const validation = validateFile(file, canonicalRoots);
+    if (validation) return { kind: "unavailable", reason: validation };
+  }
+  return { kind: "authorized", canonicalRoots: [...canonicalRoots] };
+}
+
+function validateFile(file: string, canonicalRoots: readonly string[]): string | null {
+  if (!path.isAbsolute(file) || path.normalize(file) !== file) {
+    return `Mutation file "${file}" is not a normalized absolute path.`;
+  }
+
+  let canonicalParent: string;
+  try {
+    canonicalParent = realpathSync(path.dirname(file));
+  } catch {
+    return `Mutation file "${file}" does not have a resolvable canonical parent.`;
+  }
+
+  try {
+    if (!lstatSync(file).isFile()) {
+      return `Mutation file "${file}" is not a regular file.`;
+    }
+  } catch {
+    return `Mutation file "${file}" is not a readable regular file.`;
+  }
+
+  let canonicalFile: string;
+  try {
+    canonicalFile = realpathSync(file);
+  } catch {
+    return `Mutation file "${file}" cannot be resolved to a canonical file.`;
+  }
+
+  const expectedCanonicalFile = path.join(canonicalParent, path.basename(file));
+  if (path.resolve(canonicalFile) !== path.resolve(expectedCanonicalFile)) {
+    return `Mutation file "${file}" resolves through an unsupported file link.`;
+  }
+  if (!canonicalRoots.some((root) => isWithinOrEqual(root, canonicalFile))) {
+    return `Mutation file "${file}" is outside the authorized provider roots.`;
+  }
+  return null;
+}
+
+function isWithinOrEqual(root: string, candidate: string): boolean {
+  return isMutationPathWithinRoot(root, candidate, path);
+}
+
+/** Check canonical path containment with the selected platform path rules. */
+export function isMutationPathWithinRoot(
+  root: string,
+  candidate: string,
+  pathApi: Pick<typeof path, "isAbsolute" | "relative" | "sep">,
+): boolean {
+  const difference = pathApi.relative(root, candidate);
+  return (
+    difference === "" ||
+    (difference !== ".." &&
+      !difference.startsWith(`..${pathApi.sep}`) &&
+      !pathApi.isAbsolute(difference))
+  );
+}

package/src/analysis/relations/callees.ts

@@ -2,6 +2,7 @@
  * Structural callee lookup — finds direct calls in the enclosing scope at a target position.
  */
 
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import type { CalleeEntry, CalleeScope, RelationsServiceDeps } from "./types.ts";
 
 export interface CalleesResult {
@@ -26,12 +27,19 @@ export async function collectCallees(
   deps: RelationsServiceDeps,
   maxResults?: number,
   depth: "direct" | "deep" = "direct",
+  control?: CodeRequestControl,
 ): Promise<CalleesResult> {
   if (!deps.provider?.calleesAt) {
     return unavailableCallees(targetName);
   }
 
-  const result = await deps.provider.calleesAt(targetFile, targetLine, targetCharacter, depth);
+  const depthOrOptions = control ? { depth, control } : depth;
+  const result = await deps.provider.calleesAt(
+    targetFile,
+    targetLine,
+    targetCharacter,
+    depthOrOptions,
+  );
   if (result.kind !== "success" || !result.data) {
     return unavailableCallees(targetName);
   }

package/src/analysis/relations/types.ts

@@ -1,4 +1,4 @@
-import type { SemanticProvider } from "@mrclrchtr/supi-code-runtime/api";
+import type { CodeRequestControl, SemanticProvider } from "@mrclrchtr/supi-code-runtime/api";
 
 /**
  * Shared types for the relations analysis modules.
@@ -58,7 +58,10 @@ export interface RelationsServiceDeps {
       file: string,
       line: number,
       character: number,
-      depth?: "direct" | "deep",
+      depthOrOptions?:
+        | "direct"
+        | "deep"
+        | { depth?: "direct" | "deep"; control?: CodeRequestControl },
     ) => Promise<{
       kind: string;
       data?: {

package/src/analysis/search/ast-scan-timing.ts

@@ -1,4 +1,6 @@
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
+import { truncateIdentity } from "@mrclrchtr/supi-lsp/debug-telemetry";
 import type { StructuralSearchOperation } from "@mrclrchtr/supi-tree-sitter/api";
 import type { StructuredFileAnalysis, StructuredPatternParams } from "./pattern-analysis.ts";
 
@@ -25,8 +27,11 @@ export interface AstScanTimer {
   record(input: AstScanTimingInput): void;
 }
 
-/** Start one AST scan timer without adding paths to debug-event data. */
-export function startAstScanTimer(): AstScanTimer {
+/** Start one AST scan timer, recording the workspace root as event-level cwd. */
+export function startAstScanTimer(
+  control: CodeRequestControl | undefined,
+  cwd: string,
+): AstScanTimer {
   const timer = startDebugTimer();
   return {
     enumerationCompleted() {
@@ -35,10 +40,12 @@ export function startAstScanTimer(): AstScanTimer {
     record(input) {
       timer.finish(
         () => ({
+          operationId: control?.operationId,
           source: "code-intelligence",
           level: "debug",
           category: "ast-scan.timing",
           message: `AST ${input.context.params.kind} scan analyzed ${input.analysis.analyzedFileCount} files`,
+          cwd: truncateIdentity(cwd),
           data: {
             kind: input.context.params.kind,
             operation: input.operation,

package/src/analysis/search/ast-scan.ts

@@ -292,7 +292,7 @@ class AstFileEnumerator {
   #checkControl(): boolean {
     this.options.signal?.throwIfAborted();
     if (this.#safetyLimited) return false;
-    if (this.#now() <= this.options.deadline) return true;
+    if (this.#now() < this.options.deadline) return true;
     this.#markTimeout();
     return false;
   }

package/src/analysis/search/deadline.ts

@@ -24,7 +24,7 @@ export async function settleByDeadline<T>(
 ): Promise<DeadlineOutcome<T>> {
   control.signal?.throwIfAborted();
   const remainingMs = control.deadline - control.now();
-  if (remainingMs < 0) return { kind: "timeout" };
+  if (remainingMs <= 0) return { kind: "timeout" };
 
   return new Promise<DeadlineOutcome<T>>((resolve, reject) => {
     let settled = false;
@@ -70,7 +70,7 @@ export async function settleByDeadline<T>(
       .then(
         (value) => {
           complete(
-            control.now() > control.deadline ? { kind: "timeout" } : { kind: "completed", value },
+            control.now() >= control.deadline ? { kind: "timeout" } : { kind: "completed", value },
           );
         },
         (error: unknown) => fail(error),

package/src/analysis/search/pattern-analysis.ts

@@ -1,12 +1,15 @@
-import type {
-  CodeResult,
-  OutlineData,
-  StructuralProvider as StructuralSubstrate,
+import {
+  type CodeRequestControl,
+  type CodeResult,
+  isCodeRequestDeadlineError,
+  isCodeRequestInterruption,
+  type OutlineData,
+  type StructuralProvider as StructuralSubstrate,
 } from "@mrclrchtr/supi-code-runtime/api";
 import type { CodeFindAstKind } from "../../tool/find/ast-kinds.ts";
 import type { AstScanLimitation } from "./ast-scan.ts";
 import { callableExpressionForMatching } from "./call-name.ts";
-import { settleByDeadline } from "./deadline.ts";
+import { type DeadlineOutcome, settleByDeadline } from "./deadline.ts";
 import { relativeDisplayPath } from "./paths.ts";
 
 export interface StructuredPatternParams {
@@ -52,6 +55,7 @@ interface AnalyzeStructuredFilesOptions {
   readonly deadline: number;
   readonly now: () => number;
   readonly signal?: AbortSignal;
+  readonly requestControl: CodeRequestControl;
   readonly initialLimitations: readonly AstScanLimitation[];
 }
 
@@ -67,34 +71,43 @@ export async function analyzeStructuredFiles(
 
   for (const [index, absoluteFile] of options.files.entries()) {
     options.signal?.throwIfAborted();
-    if (options.now() > options.deadline) {
+    if (options.now() >= options.deadline) {
       addAnalysisTimeout(limitations, options.files.slice(index), options.displayBase);
       break;
     }
     const relativeFile = relativeDisplayPath(options.displayBase, absoluteFile);
     const fileMatches: StructuredMatch[] = [];
     const fileFailures: StructuredFailure[] = [];
-    const outcome = await settleByDeadline(
-      async () => {
-        try {
-          await collectMatchesForFile(
-            fileMatches,
-            fileFailures,
-            options.structural,
-            relativeFile,
-            options.params.kind,
-            matcher,
-          );
-        } catch (error) {
-          fileFailures.push({
-            file: relativeFile,
-            kind: "runtime-error",
-            reason: errorMessage(error),
-          });
-        }
-      },
-      { deadline: options.deadline, now: options.now, signal: options.signal },
-    );
+    let outcome: DeadlineOutcome<void>;
+    try {
+      outcome = await settleByDeadline(
+        async () => {
+          try {
+            await collectMatchesForFile(
+              fileMatches,
+              fileFailures,
+              options.structural,
+              relativeFile,
+              options.params.kind,
+              matcher,
+              options.requestControl,
+            );
+          } catch (error) {
+            if (isCodeRequestInterruption(error, options.requestControl)) throw error;
+            fileFailures.push({
+              file: relativeFile,
+              kind: "runtime-error",
+              reason: errorMessage(error),
+            });
+          }
+        },
+        { deadline: options.deadline, now: options.now, signal: options.signal },
+      );
+    } catch (error) {
+      if (!isCodeRequestDeadlineError(error)) throw error;
+      addAnalysisTimeout(limitations, options.files.slice(index), options.displayBase);
+      break;
+    }
     if (outcome.kind === "timeout") {
       addAnalysisTimeout(limitations, options.files.slice(index), options.displayBase);
       break;
@@ -137,13 +150,14 @@ async function collectMatchesForFile(
   relFile: string,
   kind: CodeFindAstKind,
   matcher: (value: string) => boolean,
+  requestControl: CodeRequestControl,
 ): Promise<void> {
   const recordFailure = (kind: StructuredFailureKind, reason: string) => {
     failures.push({ file: relFile, kind, reason });
   };
 
   if (kind === "definition") {
-    const outline = await structural.outline(relFile);
+    const outline = await structural.outline(relFile, requestControl);
     if (!handleStructuralResult(outline, recordFailure)) return;
     for (const item of flattenOutlineItems(outline.data)) {
       if (!matcher(item.name)) continue;
@@ -153,7 +167,7 @@ async function collectMatchesForFile(
   }
 
   if (kind === "export") {
-    const exportsResult = await structural.exports(relFile);
+    const exportsResult = await structural.exports(relFile, requestControl);
     if (!handleStructuralResult(exportsResult, recordFailure)) return;
     for (const item of exportsResult.data) {
       if (!matcher(item.name)) continue;
@@ -163,7 +177,7 @@ async function collectMatchesForFile(
   }
 
   if (kind === "import") {
-    const importsResult = await structural.imports(relFile);
+    const importsResult = await structural.imports(relFile, requestControl);
     if (!handleStructuralResult(importsResult, recordFailure)) return;
     for (const item of importsResult.data) {
       if (!matcher(item.moduleSpecifier)) continue;
@@ -178,7 +192,7 @@ async function collectMatchesForFile(
   }
 
   if (kind === "call") {
-    const callResult = await structural.callSites(relFile);
+    const callResult = await structural.callSites(relFile, requestControl);
     if (!handleStructuralResult(callResult, recordFailure)) return;
     for (const call of callResult.data) {
       if (!matcher(callableExpressionForMatching(call.name))) continue;
@@ -187,7 +201,7 @@ async function collectMatchesForFile(
     return;
   }
 
-  const outline = await structural.outline(relFile);
+  const outline = await structural.outline(relFile, requestControl);
   if (!handleStructuralResult(outline, recordFailure)) return;
   for (const item of flattenOutlineItems(outline.data)) {
     if (kind === "type" && !TYPE_KIND.test(item.kind.toLowerCase())) continue;

package/src/analysis/search/pattern.ts

@@ -56,11 +56,14 @@ export type StructuredPatternOutcome =
 
 /** Internal controls for deterministic deadline, filesystem, and cancellation tests. */
 export interface StructuredPatternControl {
+  readonly operationId?: string;
   readonly signal?: AbortSignal;
   readonly now?: () => number;
   readonly operations?: AstScanOperations;
   readonly maxFiles?: number;
   readonly timeoutMs?: number;
+  /** Optional caller deadline; the earlier caller/policy deadline wins. */
+  readonly deadline?: number;
 }
 
 export interface StructuredPatternSearchOptions {
@@ -80,11 +83,12 @@ export interface StructuredPatternSearchOptions {
 export async function getStructuredPatternMatches(
   options: StructuredPatternSearchOptions,
 ): Promise<StructuredPatternOutcome> {
-  const scanTimer = startAstScanTimer();
+  const scanTimer = startAstScanTimer(options.control, options.cwd);
   const now = options.control?.now ?? Date.now;
   const maxFiles = options.control?.maxFiles ?? DEFAULT_AST_SCAN_MAX_FILES;
   const timeoutMs = options.control?.timeoutMs ?? DEFAULT_AST_SCAN_TIMEOUT_MS;
-  const deadline = now() + timeoutMs;
+  const policyDeadline = now() + timeoutMs;
+  const deadline = Math.min(options.control?.deadline ?? Number.POSITIVE_INFINITY, policyDeadline);
   const roots = Array.isArray(options.roots) ? [...options.roots] : [options.roots];
   const operation = structuralOperationForKind(options.params.kind);
   options.control?.signal?.throwIfAborted();
@@ -127,6 +131,11 @@ export async function getStructuredPatternMatches(
   }
 
   scanTimer.enumerationCompleted();
+  const requestControl = {
+    operationId: options.control?.operationId,
+    signal: options.control?.signal,
+    deadline,
+  };
   const analysis = await analyzeStructuredFiles({
     files: enumeration.files,
     displayBase: enumeration.displayBase,
@@ -135,6 +144,7 @@ export async function getStructuredPatternMatches(
     deadline,
     now,
     signal: options.control?.signal,
+    requestControl,
     initialLimitations: enumeration.limitations,
   });
   const capabilityMismatches = analysis.failures.filter(