@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/src/session/session.ts

@@ -138,6 +138,8 @@ export class WorkspaceCodeIntelligenceSession {
 
   /** Whether the hidden architecture overview has been injected. */
   #hasInjectedOverview = false;
+  /** Pinned overview setting; null until resolved once per session. */
+  #overviewEnabled: boolean | null = null;
 
   /** Most recent explicit diagnostic refresh attempt, including its established outcome. */
   #lastHealthRefreshAttempt: HealthRefreshAttempt | null = null;
@@ -166,6 +168,9 @@ export class WorkspaceCodeIntelligenceSession {
   /** Whether the project owning this session is trusted for config loading. */
   #projectTrusted = false;
 
+  /** Global config home for hermetic config reads; undefined uses os.homedir(). */
+  #homeDir: string | undefined;
+
   constructor(cwd: string, capability?: CapabilityAdapter) {
     this.cwd = cwd;
     this.#capability = capability ?? new WorkspaceCapabilityAdapter();
@@ -176,6 +181,11 @@ export class WorkspaceCodeIntelligenceSession {
     this.#projectTrusted = trusted;
   }
 
+  /** Record the global-config home used for session config reads. */
+  setHomeDir(homeDir?: string): void {
+    this.#homeDir = homeDir;
+  }
+
   /** Attach lifecycle-owned LSP state without exposing it to Tool adapters. */
   attachLspController(controller: LspRuntimeController | null): void {
     this.#lspController = controller;
@@ -194,9 +204,22 @@ export class WorkspaceCodeIntelligenceSession {
     this.#hasInjectedOverview = true;
   }
 
+  /**
+   * Pin the overview setting resolved once per session. The first resolution
+   * wins; later config changes never toggle the setting mid-session.
+   */
+  setOverviewEnabledOnce(enabled: boolean): void {
+    this.#overviewEnabled ??= enabled;
+  }
+
+  /** Whether the overview setting has been pinned for this session. */
+  hasPinnedOverview(): boolean {
+    return this.#overviewEnabled !== null;
+  }
+
   /** Atomically claim first-turn overview injection for this workspace session. */
   claimOverviewInjection(): boolean {
-    if (this.#hasInjectedOverview) return false;
+    if (this.#overviewEnabled === false || this.#hasInjectedOverview) return false;
     this.#hasInjectedOverview = true;
     return true;
   }
@@ -231,7 +254,7 @@ export class WorkspaceCodeIntelligenceSession {
       phase: "target",
       message: "Resolving target evidence",
     });
-    return resolveTargetWorkflow(
+    const outcome = await resolveTargetWorkflow(
       request.target,
       {
         fileLevelAllowed: true,
@@ -239,7 +262,10 @@ export class WorkspaceCodeIntelligenceSession {
         maxResults: request.maxResults,
       },
       this.targetWorkflowDeps(),
+      control,
     );
+    throwIfAborted(control);
+    return outcome;
   }
 
   /** Collect evidence-backed workspace health facts. */
@@ -281,6 +307,7 @@ export class WorkspaceCodeIntelligenceSession {
         surfacedInstructionDirs: this.#surfacedInstructionDirs,
         markInstructionDirsSurfaced: (directories) => this.markInstructionDirsSurfaced(directories),
         projectTrusted: this.#projectTrusted,
+        homeDir: this.#homeDir,
       },
       control,
     );

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

package/src/substrate/lsp/lifecycle.ts

@@ -4,66 +4,49 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { acquireWorkspaceProviderHost } from "../workspace-provider-host.ts";
 import { LSP_STATE_CHANGE_EVENT, type LspAdapterState } from "./state.ts";
 
-const STATE_CHANGE_EVENT = new Event(LSP_STATE_CHANGE_EVENT);
-
-/** Poll interval (ms) for detecting server readiness transitions in the footer. */
-const READINESS_POLL_MS = 2_000;
-
 /** Acquire providers once per workspace and release them after the final Pi session ends. */
 export function registerLspSessionLifecycle(
   pi: ExtensionAPI,
   state: LspAdapterState,
   onStarted?: (ctx: ExtensionContext) => void | Promise<void>,
 ): void {
-  let readinessTimer: ReturnType<typeof setInterval> | null = null;
-  let lastFingerprint = "";
+  let disposeLifecycle: (() => void) | null = null;
+  let subscriptionGeneration = 0;
 
-  function fingerprint(): string {
-    const servers = state.controller?.workspaceRuntime?.getProjectServers();
-    if (!servers) return "";
-    let ready = 0;
-    let starting = 0;
-    let error = 0;
-    let unavailable = 0;
-    let openFiles = 0;
-    for (const s of servers) {
-      openFiles += s.openFiles.length;
-      if (s.status === "running" && s.ready) ready++;
-      else if (s.status === "running") starting++;
-      else if (s.status === "error") error++;
-      else unavailable++;
-    }
-    return `${ready}:${starting}:${error}:${unavailable}:${openFiles}`;
+  function dispatchStateChange(): void {
+    state.stateChanges.dispatchEvent(new Event(LSP_STATE_CHANGE_EVENT));
   }
 
-  function startReadinessPolling(): void {
-    stopReadinessPolling();
-    lastFingerprint = fingerprint();
-    readinessTimer = setInterval(() => {
-      if (state.controller?.kind !== "ready") return;
-      const current = fingerprint();
-      if (current === lastFingerprint) return;
-      lastFingerprint = current;
-      state.stateChanges.dispatchEvent(STATE_CHANGE_EVENT);
-    }, READINESS_POLL_MS);
-    readinessTimer.unref?.();
+  function stopLifecycleSubscription(): void {
+    subscriptionGeneration++;
+    disposeLifecycle?.();
+    disposeLifecycle = null;
   }
 
-  function stopReadinessPolling(): void {
-    if (readinessTimer) {
-      clearInterval(readinessTimer);
-      readinessTimer = null;
+  function startLifecycleSubscription(): void {
+    stopLifecycleSubscription();
+    const controller = state.controller;
+    if (!controller) {
+      dispatchStateChange();
+      return;
     }
-    lastFingerprint = "";
+    const generation = subscriptionGeneration;
+    let receivedInitialTransition = false;
+    disposeLifecycle = controller.subscribeLifecycle(() => {
+      if (generation !== subscriptionGeneration) return;
+      receivedInitialTransition = true;
+      dispatchStateChange();
+    });
+    if (!receivedInitialTransition) dispatchStateChange();
   }
 
   pi.on("session_start", async (_event, ctx: ExtensionContext) => {
+    stopLifecycleSubscription();
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
     state.lspActive = false;
     state.sentinelSnapshot = new Map();
-    stopReadinessPolling();
 
     const lease = await acquireWorkspaceProviderHost(ctx.cwd, {
       projectTrusted: ctx.isProjectTrusted(),
@@ -73,19 +56,16 @@ export function registerLspSessionLifecycle(
     state.lspActive = lease.lspController?.kind === "ready";
     state.sentinelSnapshot = lease.sentinelSnapshot;
     await onStarted?.(ctx);
-
-    // Dispatch initial server list so the footer shows starting servers immediately.
-    state.stateChanges.dispatchEvent(STATE_CHANGE_EVENT);
-    // Poll for readiness transitions (running → ready, errors, etc.).
-    startReadinessPolling();
+    startLifecycleSubscription();
   });
 
   pi.on("session_shutdown", async () => {
-    stopReadinessPolling();
+    stopLifecycleSubscription();
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
     state.lspActive = false;
     state.sentinelSnapshot = new Map();
+    dispatchStateChange();
   });
 }