@mrclrchtr/supi-code-intelligence 4.10.0 → 5.0.0

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

@@ -1,6 +1,11 @@
 import { readdirSync } from "node:fs";
 import * as path from "node:path";
-import type { CodeResult, ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  type CodeRequestControl,
+  type CodeResult,
+  type ConfidenceMode,
+  isCodeRequestInterruption,
+} from "@mrclrchtr/supi-code-runtime/api";
 import { isWithinOrEqual } from "@mrclrchtr/supi-core/project";
 import type { WorkspaceLspRuntimeState } from "@mrclrchtr/supi-lsp/api";
 import type { EvidenceListMetadata, EvidencePartialReason } from "../../analysis/evidence.ts";
@@ -153,6 +158,7 @@ export async function appendStructuralFileFacts(
   builder: ContextOrientationBuilder,
   provider: CodeProvider | null,
   file: string,
+  requestControl?: CodeRequestControl,
 ): Promise<void> {
   if (!provider) {
     appendUnavailableStructuralSections(builder);
@@ -162,19 +168,22 @@ export async function appendStructuralFileFacts(
   await appendStructuralList(builder, {
     key: "structural.outline",
     title: "Provider outline",
-    collect: () => provider.outline(file),
+    collect: () => provider.outline(file, requestControl),
+    requestControl,
     render: (item) => `\`${item.name}\` (${item.kind}, L${item.startLine}–L${item.endLine})`,
   });
   await appendStructuralList(builder, {
     key: "structural.imports",
     title: "Provider imports",
-    collect: () => provider.imports(file),
+    collect: () => provider.imports(file, requestControl),
+    requestControl,
     render: (item) => `\`${item.moduleSpecifier}\``,
   });
   await appendStructuralList(builder, {
     key: "structural.exports",
     title: "Provider exports",
-    collect: () => provider.exports(file),
+    collect: () => provider.exports(file, requestControl),
+    requestControl,
     render: (item) => `\`${item.name}\` (${item.kind})`,
   });
 }
@@ -201,12 +210,14 @@ async function appendStructuralList<T>(
     title: string;
     collect: () => Promise<CodeResult<T[]>>;
     render: (item: T) => string;
+    requestControl?: CodeRequestControl;
   },
 ): Promise<void> {
   let result: CodeResult<T[]>;
   try {
     result = await input.collect();
   } catch (error) {
+    if (isCodeRequestInterruption(error, input.requestControl)) throw error;
     appendUnavailable(builder, {
       key: input.key,
       title: input.title,
@@ -246,7 +257,8 @@ export function appendPrioritySignals(
 ): void {
   if (input.lspRuntime.kind !== "ready") return;
   const scopePath = path.resolve(input.scope);
-  const entries = input.lspRuntime.runtime.getOutstandingDiagnosticSummary(2).filter((entry) => {
+  const snapshot = input.lspRuntime.runtime.getOutstandingDiagnosticSummary(2);
+  const entries = snapshot.entries.filter((entry) => {
     const file = path.resolve(input.cwd, entry.file);
     return input.isFile ? file === scopePath : isWithinOrEqual(scopePath, file);
   });
@@ -265,8 +277,9 @@ export function appendPrioritySignals(
     confidence: "semantic",
     provenance: [{ source: "semantic", capability: "LSP diagnostic snapshot" }],
     status: "partial",
-    reason:
-      "This is the current LSP snapshot, not a complete diagnostic scan; use code_health for diagnostic status.",
+    reason: snapshot.current
+      ? "This is the current LSP snapshot, not a complete diagnostic scan; use code_health for diagnostic status."
+      : "This LSP snapshot was invalidated by a document or workspace change; use code_health with refresh:true before relying on it.",
   });
 }
 

package/src/session/orientation/gather.ts

@@ -6,10 +6,12 @@
  * evidence collector in `collect.ts`.
  */
 
-import type {
-  SemanticProvider,
-  SourceRange,
-  StructuralProvider,
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+  type SemanticProvider,
+  type SourceRange,
+  type StructuralProvider,
 } from "@mrclrchtr/supi-code-runtime/api";
 
 /** Structural provider subset plus optional semantic hover/definition used for gathering. */
@@ -64,6 +66,7 @@ export async function gatherSubstrateContext(
   line: number,
   character: number,
   positionStrict: boolean,
+  requestControl?: CodeRequestControl,
 ): Promise<SubstrateContext> {
   let nodeInfo: SubstrateContext["nodeInfo"] = null;
   let outline: SubstrateContext["outline"] = [];
@@ -76,7 +79,7 @@ export async function gatherSubstrateContext(
 
   try {
     if (positionStrict) {
-      const nodeResult = await provider.nodeAt(relPath, line, character);
+      const nodeResult = await provider.nodeAt(relPath, line, character, requestControl);
       if (nodeResult.kind === "success") {
         nodeInfo = {
           type: nodeResult.data.type,
@@ -88,7 +91,7 @@ export async function gatherSubstrateContext(
       }
     }
 
-    const outlineResult = await provider.outline(relPath);
+    const outlineResult = await provider.outline(relPath, requestControl);
     if (outlineResult.kind === "success") {
       outline = outlineResult.data.map((item) => ({
         name: item.name,
@@ -98,12 +101,12 @@ export async function gatherSubstrateContext(
       }));
     }
 
-    const importsResult = await provider.imports(relPath);
+    const importsResult = await provider.imports(relPath, requestControl);
     if (importsResult.kind === "success") {
       imports = importsResult.data;
     }
 
-    const exportsResult = await provider.exports(relPath);
+    const exportsResult = await provider.exports(relPath, requestControl);
     if (exportsResult.kind === "success") {
       exports = exportsResult.data.map((item) => ({
         name: item.name,
@@ -119,7 +122,8 @@ export async function gatherSubstrateContext(
           character: character - 1,
         });
         if (hoverResult.kind !== "unavailable" && hoverResult.data) hover = hoverResult.data;
-      } catch {
+      } catch (error) {
+        if (isCodeRequestInterruption(error, requestControl)) throw error;
         // hover failed — continue without it
       }
     }
@@ -137,11 +141,13 @@ export async function gatherSubstrateContext(
             range: loc.range,
           }));
         }
-      } catch {
+      } catch (error) {
+        if (isCodeRequestInterruption(error, requestControl)) throw error;
         // definition failed — continue without it
       }
     }
-  } catch {
+  } catch (error) {
+    if (isCodeRequestInterruption(error, requestControl)) throw error;
     // Provider not available
   }
 

package/src/session/orientation-types.ts

@@ -1,4 +1,4 @@
-import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import type { CodeRequestControl, ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
 import type { WorkspaceLspRuntimeState } from "@mrclrchtr/supi-lsp/api";
 import type { ArchitectureModel } from "../analysis/architecture/model.ts";
 import type { EvidenceListMetadata } from "../analysis/evidence.ts";
@@ -37,6 +37,7 @@ export interface OrientationDeps {
   readonly provider: CodeProvider | null;
   readonly cwd: string;
   readonly lspRuntime: WorkspaceLspRuntimeState;
+  readonly requestControl?: CodeRequestControl;
 }
 
 /**

package/src/session/orientation-workflow.ts

@@ -8,7 +8,7 @@ import {
   collectInstructionFiles,
   findInstructionFilesForDirectory,
 } from "../analysis/instruction-files.ts";
-import { createStructuralCodeProvider } from "../analysis/provider.ts";
+import { createStructuralCodeProvider, withSemanticRequestControl } from "../analysis/provider.ts";
 import { normalizePath } from "../analysis/search/paths.ts";
 import { loadCodeIntelligenceConfig } from "../config.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
@@ -58,8 +58,9 @@ export async function runOrientationWorkflow(
   if (!request.focus) {
     const result = await executeOrientation(
       { maxResults },
-      { model, provider, lspRuntime, cwd: deps.cwd },
+      { model, provider, lspRuntime, cwd: deps.cwd, requestControl: control },
     );
+    throwIfAborted(control);
     return { kind: "completed", data: result };
   }
 
@@ -74,8 +75,9 @@ export async function runOrientationWorkflow(
       focus: focus.path,
       maxResults,
     },
-    { model, provider, lspRuntime, cwd: deps.cwd },
+    { model, provider, lspRuntime, cwd: deps.cwd, requestControl: control },
   );
+  throwIfAborted(control);
   const withInstructions = addInstructionFiles(result, focus.path, deps);
   return { kind: "completed", data: withInstructions };
 }
@@ -101,7 +103,9 @@ async function orientTarget(options: {
       maxResults,
     },
     deps,
+    control,
   );
+  throwIfAborted(control);
   if (target.kind === "target-group") {
     return {
       kind: "invalid-input",
@@ -133,13 +137,14 @@ async function orientTarget(options: {
   throwIfAborted(control);
 
   const entry = target.entry;
-  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-    kind: "file",
-    file: entry.file,
-  });
+  const readiness = await deps.capability.ensureSemanticReadiness(
+    deps.cwd,
+    { kind: "file", file: entry.file },
+    control,
+  );
   const semanticReady = readiness.kind === "ready";
   const provider = semanticReady
-    ? deps.capability.getProvider(deps.cwd)
+    ? withSemanticRequestControl(deps.capability.getProvider(deps.cwd), control)
     : createStructuralCodeProvider(deps.capability.getStructuralProvider(deps.cwd));
   const lspRuntime = semanticReady
     ? deps.capability.getLspRuntimeState(deps.cwd)
@@ -154,8 +159,10 @@ async function orientTarget(options: {
       provider,
       lspRuntime,
       cwd: deps.cwd,
+      requestControl: control,
     },
   );
+  throwIfAborted(control);
   return {
     kind: "completed",
     data: addTargetSummary(result, entry, target.notes, deps.cwd),

package/src/session/refactor-plans.ts

@@ -19,6 +19,8 @@ export interface RefactorPlan {
   targetLine: number;
   targetCharacter: number;
   edits: WorkspaceEdit;
+  /** Canonical roots that the routed semantic provider authorized. */
+  authorizedMutationRoots: string[];
   fileFingerprints: Array<{ file: string; fingerprint: string }>;
   createdAt: number;
 }

package/src/session/refactor-workflow.ts

@@ -8,6 +8,10 @@ import type {
 } from "@mrclrchtr/supi-code-runtime/api";
 import { toLspPosition } from "@mrclrchtr/supi-lsp/api";
 import { applyWorkspaceEdit } from "../analysis/refactor/apply.ts";
+import {
+  establishMutationAuthority,
+  revalidateMutationAuthority,
+} from "../analysis/refactor/mutation-authority.ts";
 import { validateEdit } from "../analysis/refactor/safety.ts";
 import { normalizePath } from "../analysis/search/paths.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
@@ -66,7 +70,9 @@ export async function runRefactorPlanWorkflow(
       nameAnchorRequired: parsed.operation === "rename_symbol",
     },
     deps,
+    control,
   );
+  throwIfAborted(control);
   if (target.kind === "target-group") {
     return {
       kind: "invalid-input",
@@ -81,10 +87,11 @@ export async function runRefactorPlanWorkflow(
   }
   if (target.kind !== "resolved") return target;
 
-  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-    kind: "file",
-    file: target.entry.file,
-  });
+  const readiness = await deps.capability.ensureSemanticReadiness(
+    deps.cwd,
+    { kind: "file", file: target.entry.file },
+    control,
+  );
   if (readiness.kind === "timeout") {
     return { kind: "unavailable", reason: "Semantic readiness timed out." };
   }
@@ -92,13 +99,17 @@ export async function runRefactorPlanWorkflow(
   throwIfAborted(control);
 
   const file = normalizePath(target.entry.file, deps.cwd);
-  const result = await planWithProvider(deps.capability.getSemanticProvider(deps.cwd), {
-    operation: parsed.operation,
-    file,
-    position: toLspPosition(target.entry.displayLine, target.entry.displayCharacter),
-    range: parsed.range ? toLspRange(parsed.range) : undefined,
-    newName: parsed.newName,
-  });
+  const result = await planWithProvider(
+    deps.capability.getSemanticProvider(deps.cwd),
+    {
+      operation: parsed.operation,
+      file,
+      position: toLspPosition(target.entry.displayLine, target.entry.displayCharacter),
+      range: parsed.range ? toLspRange(parsed.range) : undefined,
+      newName: parsed.newName,
+    },
+    control,
+  );
   if (result.kind === "unavailable") return result;
   if (result.kind === "ambiguous") {
     return { kind: "ambiguous", candidates: result.candidates };
@@ -108,6 +119,11 @@ export async function runRefactorPlanWorkflow(
   if (!validation.safe) {
     return { kind: "invalid-input", message: `Refactor safety check failed: ${validation.reason}` };
   }
+  const authority = establishMutationAuthority(
+    result.edits.edits.map((edit) => edit.file),
+    result.authorizedMutationRoots,
+  );
+  if (authority.kind === "unavailable") return authority;
 
   const plan: RefactorPlan = {
     id: generatePlanId(
@@ -123,6 +139,7 @@ export async function runRefactorPlanWorkflow(
     targetLine: target.entry.displayLine,
     targetCharacter: target.entry.displayCharacter,
     edits: result.edits,
+    authorizedMutationRoots: authority.canonicalRoots,
     fileFingerprints: collectFileFingerprints(result.edits.edits),
     createdAt: Date.now(),
   };
@@ -147,6 +164,11 @@ export async function runRefactorApplyWorkflow(
     };
   }
 
+  const authority = revalidateMutationAuthority(
+    plan.edits.edits.map((edit) => edit.file),
+    plan.authorizedMutationRoots,
+  );
+  if (authority.kind === "unavailable") return authority;
   const freshness = isPlanFresh(plan);
   if (!freshness.fresh) return { kind: "invalid-input", message: freshness.reason };
   const validation = validateEdit(plan.edits);
@@ -161,12 +183,26 @@ export async function runRefactorApplyWorkflow(
   const expectedFingerprints = new Map(
     plan.fileFingerprints.map(({ file, fingerprint }) => [file, fingerprint]),
   );
-  const result = await applyWorkspaceEdit(plan.edits, { expectedFingerprints });
+  const getOpenDocumentVersion = getDocumentVersionReader(deps);
+  const result = await applyWorkspaceEdit(plan.edits, {
+    authorizedMutationRoots: plan.authorizedMutationRoots,
+    expectedFingerprints,
+    getOpenDocumentVersion,
+  });
   if (result.kind === "error") return { kind: "unavailable", reason: result.reason };
   deps.removePlan(plan.id);
   return { kind: "completed", plan: immutablePlan(plan), result };
 }
 
+function getDocumentVersionReader(
+  deps: RefactorWorkflowDeps,
+): ((file: string) => number | null) | undefined {
+  const state = deps.capability.getLspRuntimeState(deps.cwd);
+  if (state.kind !== "ready" && state.kind !== "inactive") return undefined;
+  if (typeof state.runtime.getOpenDocumentVersion !== "function") return undefined;
+  return (file) => state.runtime.getOpenDocumentVersion(file);
+}
+
 function parseOperation(input: RefactorOperationInput):
   | {
       kind: "ok";
@@ -230,11 +266,12 @@ async function planWithProvider(
     range?: SourceRange;
     newName: string;
   },
+  control?: WorkflowControl,
 ): Promise<RefactorResult> {
   if (!provider) return { kind: "unavailable", reason: "No semantic provider is active." };
-  if (provider.refactor) return provider.refactor(request);
+  if (provider.refactor) return provider.refactor(request, control);
   if (request.operation === "rename_symbol" && provider.rename) {
-    return provider.rename(request.file, request.position, request.newName);
+    return provider.rename(request.file, request.position, request.newName, control);
   }
   return {
     kind: "unavailable",
@@ -255,7 +292,15 @@ function immutablePlan(plan: RefactorPlan): Readonly<RefactorPlan> {
     edits: Object.freeze({
       ...plan.edits,
       edits: Object.freeze(plan.edits.edits.map((edit) => Object.freeze({ ...edit }))),
+      documentPreconditions: plan.edits.documentPreconditions
+        ? Object.freeze(
+            plan.edits.documentPreconditions.map((precondition) =>
+              Object.freeze({ ...precondition }),
+            ),
+          )
+        : undefined,
     }),
+    authorizedMutationRoots: Object.freeze([...plan.authorizedMutationRoots]),
     fileFingerprints: Object.freeze(
       plan.fileFingerprints.map((fingerprint) => Object.freeze({ ...fingerprint })),
     ),

package/src/session/session.ts

@@ -231,7 +231,7 @@ export class WorkspaceCodeIntelligenceSession {
       phase: "target",
       message: "Resolving target evidence",
     });
-    return resolveTargetWorkflow(
+    const outcome = await resolveTargetWorkflow(
       request.target,
       {
         fileLevelAllowed: true,
@@ -239,7 +239,10 @@ export class WorkspaceCodeIntelligenceSession {
         maxResults: request.maxResults,
       },
       this.targetWorkflowDeps(),
+      control,
     );
+    throwIfAborted(control);
+    return outcome;
   }
 
   /** Collect evidence-backed workspace health facts. */

package/src/session/target-workflow.ts

@@ -4,8 +4,10 @@
  * Turns one exact target selector into immutable resolved-target facts before
  * graph, Orientation, resolve, or refactor analysis begins.
  */
-
+// biome-ignore lint/style/noExcessiveLinesPerFile: target workflow keeps anchored, symbol, and file resolution together.
 import { existsSync } from "node:fs";
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
+import { withSemanticRequestControl, withStructuralRequestControl } from "../analysis/provider.ts";
 import { normalizePath, resolveScope } from "../analysis/search/paths.ts";
 import { resolveAnchoredSymbolTarget } from "../analysis/target/anchored.ts";
 import { resolveFileTargetGroup, validateFileTargetDiscovery } from "../analysis/target/file.ts";
@@ -87,6 +89,7 @@ export async function resolveTargetWorkflow(
   input: TargetInput,
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
+  control?: CodeRequestControl,
 ): Promise<TargetWorkflowOutcome> {
   const parsed = parseTargetInput(input, ["handle", "anchor", "symbol", "file"]);
   if (parsed.kind === "invalid-input") return parsed;
@@ -96,10 +99,10 @@ export async function resolveTargetWorkflow(
     return resolveHandle(target.handle, policy, deps);
   }
   if ("anchor" in target) {
-    return resolveAnchoredWorkflow(target.anchor, policy, deps);
+    return resolveAnchoredWorkflow(target.anchor, policy, deps, control);
   }
   if ("symbol" in target) {
-    return resolveSymbolWorkflow(target.symbol, policy, deps);
+    return resolveSymbolWorkflow(target.symbol, policy, deps, control);
   }
   if (!policy.fileLevelAllowed) {
     return {
@@ -107,7 +110,7 @@ export async function resolveTargetWorkflow(
       message: "This workflow requires a handle, anchored point, or symbol target.",
     };
   }
-  return resolveFileOnlyWorkflow(target.file, policy.maxResults ?? 10, deps);
+  return resolveFileOnlyWorkflow(target.file, policy.maxResults ?? 10, deps, control);
 }
 
 function resolveHandle(
@@ -134,16 +137,18 @@ async function resolveAnchoredWorkflow(
   anchor: { file: string; line: number; character: number },
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
+  control?: CodeRequestControl,
 ): Promise<TargetWorkflowOutcome> {
   const file = normalizePath(anchor.file, deps.cwd);
   if (!existsSync(file)) {
     return { kind: "invalid-input", message: `File not found: \`${anchor.file}\`` };
   }
 
-  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-    kind: "file",
-    file,
-  });
+  const readiness = await deps.capability.ensureSemanticReadiness(
+    deps.cwd,
+    { kind: "file", file },
+    control,
+  );
   if (readiness.kind === "timeout") {
     return {
       kind: "unavailable",
@@ -158,13 +163,19 @@ async function resolveAnchoredWorkflow(
     file,
     anchor.line,
     anchor.character,
-    deps.capability.getProvider(deps.cwd),
+    withSemanticRequestControl(
+      withStructuralRequestControl(deps.capability.getProvider(deps.cwd), control),
+      control,
+    ),
+    control,
   );
   return toWorkflowOutcome(
     await refineTargetOutcomeIdentity(
       outcome,
       deps.cwd,
-      deps.capability.getStructuralProvider(deps.cwd) ?? undefined,
+      withStructuralRequestControl(deps.capability.getStructuralProvider(deps.cwd), control) ??
+        undefined,
+      control,
     ),
     policy,
     deps,
@@ -175,6 +186,7 @@ async function resolveSymbolWorkflow(
   symbol: { query: string; scope?: string; symbolKind?: TargetSymbolKind },
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
+  control?: CodeRequestControl,
 ): Promise<TargetWorkflowOutcome> {
   if (!symbol.query.trim()) {
     return { kind: "invalid-input", message: "Symbol query must not be empty." };
@@ -189,9 +201,11 @@ async function resolveSymbolWorkflow(
     scope = resolved.path;
   }
 
-  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: "LSP readiness timed out. Retry shortly." };
   }
@@ -199,7 +213,10 @@ async function resolveSymbolWorkflow(
     return { kind: "unavailable", reason: readiness.reason };
   }
 
-  const provider = deps.capability.getSemanticProvider(deps.cwd);
+  const provider = withSemanticRequestControl(
+    deps.capability.getSemanticProvider(deps.cwd),
+    control,
+  );
   if (!provider) {
     return {
       kind: "unavailable",
@@ -211,12 +228,15 @@ async function resolveSymbolWorkflow(
     path: scope,
     kind: symbol.symbolKind,
     maxResults: policy.maxResults,
+    control,
   });
   return toWorkflowOutcome(
     await refineTargetOutcomeIdentity(
       outcome,
       deps.cwd,
-      deps.capability.getStructuralProvider(deps.cwd) ?? undefined,
+      withStructuralRequestControl(deps.capability.getStructuralProvider(deps.cwd), control) ??
+        undefined,
+      control,
     ),
     policy,
     deps,
@@ -227,15 +247,17 @@ async function resolveFileOnlyWorkflow(
   requestedFile: string,
   maxResults: number,
   deps: TargetWorkflowDeps,
+  control?: CodeRequestControl,
 ): Promise<TargetWorkflowOutcome> {
   const validation = validateFileTargetDiscovery(requestedFile, deps.cwd);
   if (validation.kind === "invalid-input") return validation;
   const file = validation.file;
 
-  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-    kind: "file",
-    file,
-  });
+  const readiness = await deps.capability.ensureSemanticReadiness(
+    deps.cwd,
+    { kind: "file", file },
+    control,
+  );
   if (readiness.kind === "timeout") {
     return { kind: "unavailable", reason: "LSP readiness timed out. Retry shortly." };
   }
@@ -243,10 +265,19 @@ async function resolveFileOnlyWorkflow(
     return { kind: "unavailable", reason: readiness.reason };
   }
 
-  const result = await resolveFileTargetGroup(file, deps.cwd, {
-    semantic: deps.capability.getSemanticProvider(deps.cwd) ?? undefined,
-    structural: deps.capability.getStructuralProvider(deps.cwd) ?? undefined,
-  });
+  const result = await resolveFileTargetGroup(
+    file,
+    deps.cwd,
+    {
+      semantic:
+        withSemanticRequestControl(deps.capability.getSemanticProvider(deps.cwd), control) ??
+        undefined,
+      structural:
+        withStructuralRequestControl(deps.capability.getStructuralProvider(deps.cwd), control) ??
+        undefined,
+    },
+    control,
+  );
   if (result.kind === "invalid-input") return result;
   if (result.kind === "unavailable") {
     return { kind: "unavailable", reason: result.message };

package/src/session/workflow-control.ts

@@ -1,3 +1,8 @@
+import {
+  type CodeRequestControl,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
+
 /** Execution controls shared by Workspace code-intelligence session workflows. */
 
 /** Stable progress event emitted by a session-owned workflow. */
@@ -16,8 +21,7 @@ export interface WorkflowProgressEvent {
 }
 
 /** Per-call cancellation and progress controls. */
-export interface WorkflowControl {
-  readonly signal?: AbortSignal;
+export interface WorkflowControl extends CodeRequestControl {
   readonly progress?: (event: WorkflowProgressEvent) => void;
 }
 
@@ -31,5 +35,5 @@ export function reportProgress(
 
 /** Throw the platform-standard cancellation reason before starting a phase. */
 export function throwIfAborted(control: WorkflowControl | undefined): void {
-  control?.signal?.throwIfAborted();
+  throwIfCodeRequestInterrupted(control);
 }