@mrclrchtr/supi-code-intelligence 5.0.0 → 6.0.1

package/node_modules/@mrclrchtr/supi-tree-sitter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "5.0.0",
+  "version": "6.0.1",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,8 @@
   "dependencies": {
     "jiti": "^2.7.0",
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-code-runtime": "5.0.0",
-    "@mrclrchtr/supi-core": "5.0.0"
+    "@mrclrchtr/supi-code-runtime": "6.0.1",
+    "@mrclrchtr/supi-core": "6.0.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "5.0.0",
+  "version": "6.0.1",
   "description": "LSP and AST navigation, search, diagnostics, and refactoring",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-core": "5.0.0",
-    "@mrclrchtr/supi-lsp": "5.0.0",
-    "@mrclrchtr/supi-tree-sitter": "5.0.0",
-    "@mrclrchtr/supi-code-runtime": "5.0.0"
+    "@mrclrchtr/supi-code-runtime": "6.0.1",
+    "@mrclrchtr/supi-tree-sitter": "6.0.1",
+    "@mrclrchtr/supi-lsp": "6.0.1",
+    "@mrclrchtr/supi-core": "6.0.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/analysis/health/diagnostics.ts

@@ -3,25 +3,28 @@
 
 import { existsSync, statSync } from "node:fs";
 import { relative, resolve } from "node:path";
-import {
-  type CodeRequestControl,
-  isCodeRequestInterruption,
-} from "@mrclrchtr/supi-code-runtime/api";
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import { isWithinOrEqual } from "@mrclrchtr/supi-core/api";
 import type {
-  Diagnostic,
   DiagnosticEvidenceDocument,
   DiagnosticEvidenceSummary,
+  WorkspaceDiagnosticReport,
   WorkspaceLspRuntime,
 } from "@mrclrchtr/supi-lsp/api";
 import { mergeDiagnosticEvidence } from "../../diagnostics/evidence.ts";
 import type {
   HealthDiagnosticEntry,
-  HealthDiagnosticMessage,
   HealthDiagnosticObservation,
   HealthDiagnosticScope,
   HealthSection,
 } from "../../session/health-types.ts";
+import {
+  collectScopedFileDiagnostics,
+  fileScopeStatus,
+  toFileDiagnosticEntries,
+  unavailableDiagnostics,
+  unavailableFileEvidence,
+} from "./file-scope.ts";
 
 // ── Diagnostics ───────────────────────────────────────────────────────
 
@@ -47,8 +50,10 @@ interface CollectDiagnosticsOptions {
   /** Collect individual messages per file (detailed level). */
   readonly detailed?: boolean;
   readonly requestControl?: CodeRequestControl;
-  /** Final evidence from an explicit workspace refresh, when one ran. */
+  /** Evidence from an explicit workspace refresh, when one ran. */
   readonly refreshEvidence?: DiagnosticEvidenceSummary;
+  /** Coherent final report from an explicit workspace refresh, when one ran. */
+  readonly refreshReport?: WorkspaceDiagnosticReport;
 }
 
 /** Collect diagnostics without widening the requested evidence scope. */
@@ -61,75 +66,49 @@ export async function collectDiagnostics(
     return unavailableDiagnostics(
       scope,
       unavailableReason,
-      unavailableScopeEvidence(scope, options.refreshEvidence, options.evidenceService, cwd),
+      unavailableScopeEvidence({
+        scope,
+        refreshEvidence: options.refreshEvidence,
+        refreshReport: options.refreshReport,
+        evidenceService: options.evidenceService,
+        cwd,
+      }),
+      scope.kind === "file" ? fileScopeStatus(scope.path, cwd) : undefined,
     );
   }
 
   return scope.kind === "file"
-    ? collectScopedFileDiagnostics(service, scope, detailed, requestControl)
+    ? collectScopedFileDiagnostics({ service, scope, cwd, detailed, requestControl })
     : collectTrackedFileDiagnostics({
         service,
         scope,
         cwd,
         detailed,
         refreshEvidence: options.refreshEvidence,
+        refreshReport: options.refreshReport,
       });
 }
 
-async function collectScopedFileDiagnostics(
-  service: WorkspaceLspRuntime,
-  scope: Extract<HealthDiagnosticScope, { kind: "file" }>,
-  detailed?: boolean,
-  requestControl?: CodeRequestControl,
-): Promise<HealthDiagnosticObservation> {
-  try {
-    const result = await service.fileDiagnostics(scope.path, 4, requestControl);
-    if (result.kind === "unavailable") {
-      return unavailableDiagnostics(scope, result.reason, unavailableFileEvidence(scope.path));
-    }
-
-    const entries = toFileDiagnosticEntries(scope.path, result.data, detailed);
-    return result.kind === "partial"
-      ? {
-          kind: "partial",
-          scope,
-          entries,
-          evidence: singleFileEvidence(scope.path, "unconfirmed"),
-          reason: result.reason,
-        }
-      : {
-          kind: "completed",
-          scope,
-          entries,
-          evidence: singleFileEvidence(scope.path, "confirmed"),
-        };
-  } catch (error) {
-    if (isCodeRequestInterruption(error, requestControl)) throw error;
-    return unavailableDiagnostics(
-      scope,
-      errorMessage(error, "File diagnostic request failed."),
-      unavailableFileEvidence(scope.path),
-    );
-  }
-}
-
 interface TrackedFileDiagnosticOptions {
   readonly service: WorkspaceLspRuntime;
   readonly scope: Extract<HealthDiagnosticScope, { kind: "tracked-files" }>;
   readonly cwd: string;
   readonly detailed?: boolean;
   readonly refreshEvidence?: DiagnosticEvidenceSummary;
+  readonly refreshReport?: WorkspaceDiagnosticReport;
 }
 
 function collectTrackedFileDiagnostics(
   options: TrackedFileDiagnosticOptions,
 ): HealthDiagnosticObservation {
-  const { service, scope, cwd, detailed, refreshEvidence } = options;
+  const { service, scope, cwd, detailed, refreshEvidence, refreshReport } = options;
   try {
     const snapshot = detailed
-      ? collectWorkspaceDiagnosticsDetailed(service, scope.filter, cwd)
-      : collectWorkspaceDiagnostics(service, scope.filter, cwd);
-    const sourceEvidence = mergeEvidence(refreshEvidence, snapshot.evidence, cwd);
+      ? collectWorkspaceDiagnosticsDetailed(service, scope.filter, cwd, refreshReport)
+      : collectWorkspaceDiagnostics(service, scope.filter, cwd, refreshReport);
+    const sourceEvidence = refreshReport
+      ? snapshot.evidence
+      : mergeEvidence(refreshEvidence, snapshot.evidence, cwd);
     const scopedEvidence = selectTrackedFileEvidence(sourceEvidence, scope.filter, cwd);
     const evidence = ensureEvidenceCoversEntries(scopedEvidence, snapshot.entries, cwd);
     return evidenceIsComplete(evidence, snapshot.entries.length > 0, snapshot.current)
@@ -142,8 +121,9 @@ function collectTrackedFileDiagnostics(
           reason: diagnosticEvidenceReason(evidence),
         };
   } catch (error) {
-    const evidence = options.refreshEvidence
-      ? selectTrackedFileEvidence(options.refreshEvidence, scope.filter, cwd)
+    const evidenceSource = options.refreshReport?.summary.evidence ?? options.refreshEvidence;
+    const evidence = evidenceSource
+      ? selectTrackedFileEvidence(evidenceSource, scope.filter, cwd)
       : emptyEvidence();
     return unavailableDiagnostics(
       scope,
@@ -153,31 +133,17 @@ function collectTrackedFileDiagnostics(
   }
 }
 
-function toFileDiagnosticEntries(
-  file: string,
-  diagnostics: ReadonlyArray<Pick<Diagnostic, "severity" | "message" | "source" | "range">>,
-  detailed?: boolean,
-): HealthDiagnosticEntry[] {
-  const errors = diagnostics.filter((diagnostic) => (diagnostic.severity ?? 1) === 1).length;
-  const warnings = diagnostics.filter((diagnostic) => (diagnostic.severity ?? 1) === 2).length;
-  if (!hasIssueCounts(errors, warnings)) return [];
-  const entry: HealthDiagnosticEntry = { file, errors, warnings };
-  if (detailed) {
-    return [{ ...entry, messages: extractMessages(diagnostics) }];
-  }
-  return [entry];
-}
-
 function collectWorkspaceDiagnostics(
   service: WorkspaceLspRuntime,
   scopeFilter: string | null,
   cwd: string,
+  report?: WorkspaceDiagnosticReport,
 ): {
   entries: HealthDiagnosticEntry[];
   current: boolean;
   evidence: DiagnosticEvidenceSummary;
 } {
-  const summary = service.getWorkspaceDiagnosticSummary();
+  const summary = report?.summary ?? service.getWorkspaceDiagnosticSummary();
   const result: HealthDiagnosticEntry[] = [];
 
   for (const entry of summary.entries) {
@@ -195,12 +161,13 @@ function collectWorkspaceDiagnosticsDetailed(
   service: WorkspaceLspRuntime,
   scopeFilter: string | null,
   cwd: string,
+  report?: WorkspaceDiagnosticReport,
 ): {
   entries: HealthDiagnosticEntry[];
   current: boolean;
   evidence: DiagnosticEvidenceSummary;
 } {
-  const outstanding = service.getOutstandingDiagnostics(2);
+  const outstanding = report?.outstanding ?? service.getOutstandingDiagnostics(2);
   const result: HealthDiagnosticEntry[] = [];
 
   for (const { file, diagnostics } of outstanding.entries) {
@@ -213,37 +180,24 @@ function collectWorkspaceDiagnosticsDetailed(
   return { entries: result, current: outstanding.current, evidence: outstanding.evidence };
 }
 
-// ── Message extraction ────────────────────────────────────────────────
-
-const MAX_MESSAGES_PER_FILE = 3;
-
-function extractMessages(
-  diagnostics: ReadonlyArray<Pick<Diagnostic, "severity" | "message" | "source" | "range">>,
-): HealthDiagnosticMessage[] {
-  const errorsAndWarnings = diagnostics
-    .filter((d) => (d.severity ?? 1) <= 2)
-    .sort(
-      (a, b) => (a.severity ?? 1) - (b.severity ?? 1) || a.range.start.line - b.range.start.line,
-    );
-
-  return errorsAndWarnings.slice(0, MAX_MESSAGES_PER_FILE).map((d) => ({
-    line: d.range.start.line + 1,
-    severity: (d.severity ?? 1) === 1 ? ("error" as const) : ("warning" as const),
-    message: typeof d.message === "string" ? d.message : d.message.value,
-    ...(d.source ? { source: d.source } : {}),
-  }));
+interface UnavailableScopeEvidenceOptions {
+  readonly scope: HealthDiagnosticScope;
+  readonly refreshEvidence?: DiagnosticEvidenceSummary;
+  readonly refreshReport?: WorkspaceDiagnosticReport;
+  readonly evidenceService?: WorkspaceLspRuntime | null;
+  readonly cwd: string;
 }
 
 function unavailableScopeEvidence(
-  scope: HealthDiagnosticScope,
-  refreshEvidence: DiagnosticEvidenceSummary | undefined,
-  evidenceService: WorkspaceLspRuntime | null | undefined,
-  cwd: string,
+  options: UnavailableScopeEvidenceOptions,
 ): DiagnosticEvidenceSummary {
-  const runtimeEvidence = readRuntimeEvidence(evidenceService);
-  const knownEvidence = refreshEvidence
-    ? mergeDiagnosticEvidence(refreshEvidence, runtimeEvidence, cwd, "conservative")
-    : runtimeEvidence;
+  const { scope, refreshEvidence, refreshReport, evidenceService, cwd } = options;
+  const runtimeEvidence = refreshReport?.summary.evidence ?? readRuntimeEvidence(evidenceService);
+  const knownEvidence = refreshReport
+    ? runtimeEvidence
+    : refreshEvidence
+      ? mergeDiagnosticEvidence(refreshEvidence, runtimeEvidence, cwd, "conservative")
+      : runtimeEvidence;
   if (knownEvidence.requested === 0 && knownEvidence.documents.length === 0) {
     return scope.kind === "file" ? unavailableFileEvidence(scope.path) : emptyEvidence();
   }
@@ -256,10 +210,6 @@ function unavailableScopeEvidence(
   return scope.kind === "file" ? unavailableFileEvidence(scope.path) : scoped;
 }
 
-function unavailableFileEvidence(file: string): DiagnosticEvidenceSummary {
-  return singleFileEvidence(file, existsSync(file) ? "failed" : "removed");
-}
-
 function readRuntimeEvidence(
   service: WorkspaceLspRuntime | null | undefined,
 ): DiagnosticEvidenceSummary {
@@ -271,14 +221,6 @@ function readRuntimeEvidence(
   }
 }
 
-function unavailableDiagnostics(
-  scope: HealthDiagnosticScope,
-  reason: string,
-  evidence: DiagnosticEvidenceSummary = emptyEvidence(),
-): HealthDiagnosticObservation {
-  return { kind: "unavailable", scope, entries: [], evidence, reason };
-}
-
 function errorMessage(error: unknown, fallback: string): string {
   return error instanceof Error && error.message ? error.message : fallback;
 }
@@ -298,20 +240,6 @@ function emptyEvidence(): DiagnosticEvidenceSummary {
   };
 }
 
-function singleFileEvidence(
-  file: string,
-  status: DiagnosticEvidenceDocument["status"],
-): DiagnosticEvidenceSummary {
-  return {
-    requested: 1,
-    confirmed: status === "confirmed" ? 1 : 0,
-    unconfirmed: status === "unconfirmed" ? 1 : 0,
-    failed: status === "failed" ? 1 : 0,
-    removed: status === "removed" ? 1 : 0,
-    documents: [{ file, status }],
-  };
-}
-
 function mergeEvidence(
   refreshEvidence: DiagnosticEvidenceSummary | undefined,
   snapshotEvidence: DiagnosticEvidenceSummary,
@@ -375,15 +303,19 @@ function evidenceIsComplete(
   if (!snapshotCurrent && evidence.requested === 0) return false;
   if (evidence.requested === 0) return !hasDiagnosticEntries;
   return (
-    evidence.confirmed === evidence.requested &&
+    evidence.confirmed + evidence.removed === evidence.requested &&
     evidence.unconfirmed === 0 &&
-    evidence.failed === 0 &&
-    evidence.removed === 0
+    evidence.failed === 0
   );
 }
 
 function diagnosticEvidenceReason(evidence: DiagnosticEvidenceSummary): string {
-  return `Diagnostic evidence is partial: ${evidence.requested} requested, ${evidence.confirmed} confirmed, ${evidence.unconfirmed} unconfirmed, ${evidence.failed} failed, ${evidence.removed} removed.`;
+  let reason = `Diagnostic evidence is partial: ${evidence.requested} requested, ${evidence.confirmed} confirmed, ${evidence.unconfirmed} unconfirmed, ${evidence.failed} failed, ${evidence.removed} removed.`;
+  if (evidence.unconfirmed > 0) {
+    reason +=
+      " Unconfirmed documents await a later diagnostic republish before their evidence can be confirmed (ADR 0021).";
+  }
+  return reason;
 }
 
 export function isDirectory(filePath: string): boolean {

package/src/analysis/health/file-scope.ts

@@ -0,0 +1,184 @@
+// Single-file diagnostics collection for code_health.
+//
+// Owns the file-scope health request: the live pull, the tsconfig scope
+// decision for the requested file, and the evidence factories shared by the
+// file-scope outcomes. Kept separate from the workspace-tracked collection
+// (diagnostics.ts) so the scope-decision surface stays in one place.
+
+import { existsSync } from "node:fs";
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+} from "@mrclrchtr/supi-code-runtime/api";
+import {
+  type Diagnostic,
+  type DiagnosticEvidenceDocument,
+  type DiagnosticEvidenceSummary,
+  type FileScopeDecision,
+  getFileScopeDecision,
+  TENTATIVE_PUSH_UNAVAILABLE_REASON,
+  type WorkspaceLspRuntime,
+} from "@mrclrchtr/supi-lsp/api";
+import type {
+  HealthDiagnosticEntry,
+  HealthDiagnosticMessage,
+  HealthDiagnosticObservation,
+  HealthDiagnosticScope,
+} from "../../session/health-types.ts";
+
+/** Collect a live per-file diagnostic pull with its tsconfig scope decision. */
+export async function collectScopedFileDiagnostics(options: {
+  service: WorkspaceLspRuntime;
+  scope: Extract<HealthDiagnosticScope, { kind: "file" }>;
+  cwd: string;
+  detailed?: boolean;
+  requestControl?: CodeRequestControl;
+}): Promise<HealthDiagnosticObservation> {
+  const { service, scope, cwd, detailed, requestControl } = options;
+  try {
+    const result = await service.fileDiagnostics(scope.path, 4, requestControl);
+    if (result.kind === "unavailable") {
+      const evidence =
+        result.reason === TENTATIVE_PUSH_UNAVAILABLE_REASON
+          ? singleFileEvidence(scope.path, "unconfirmed")
+          : unavailableFileEvidence(scope.path);
+      return unavailableDiagnostics(
+        scope,
+        result.reason,
+        evidence,
+        fileScopeStatus(scope.path, cwd),
+      );
+    }
+
+    const entries = toFileDiagnosticEntries(scope.path, result.data, detailed);
+    const status = fileScopeStatus(scope.path, cwd);
+    return result.kind === "partial"
+      ? {
+          kind: "partial",
+          scope,
+          entries,
+          evidence: singleFileEvidence(scope.path, "unconfirmed"),
+          reason: result.reason,
+          ...(status ? { scopeStatus: status } : {}),
+        }
+      : {
+          kind: "completed",
+          scope,
+          entries,
+          evidence: singleFileEvidence(scope.path, "confirmed"),
+          ...(status ? { scopeStatus: status } : {}),
+        };
+  } catch (error) {
+    if (isCodeRequestInterruption(error, requestControl)) throw error;
+    return unavailableDiagnostics(
+      scope,
+      errorMessage(error, "File diagnostic request failed."),
+      unavailableFileEvidence(scope.path),
+      fileScopeStatus(scope.path, cwd),
+    );
+  }
+}
+
+/**
+ * Tsconfig scope decision for the requested file, when it can be computed.
+ *
+ * Uses the same decision model the diagnostic filter delegates to, so the
+ * rendered status line cannot drift from filter behavior. Telemetry-only:
+ * a failure to compute never fails the diagnostic request.
+ */
+export function fileScopeStatus(filePath: string, cwd: string): FileScopeDecision | null {
+  try {
+    return getFileScopeDecision(filePath, cwd);
+  } catch {
+    return null;
+  }
+}
+
+export function toFileDiagnosticEntries(
+  file: string,
+  diagnostics: ReadonlyArray<Pick<Diagnostic, "severity" | "message" | "source" | "range">>,
+  detailed?: boolean,
+): HealthDiagnosticEntry[] {
+  const errors = diagnostics.filter((diagnostic) => (diagnostic.severity ?? 1) === 1).length;
+  const warnings = diagnostics.filter((diagnostic) => (diagnostic.severity ?? 1) === 2).length;
+  if (!hasIssueCounts(errors, warnings)) return [];
+  const entry: HealthDiagnosticEntry = { file, errors, warnings };
+  if (detailed) {
+    return [{ ...entry, messages: extractMessages(diagnostics) }];
+  }
+  return [entry];
+}
+
+// ── Message extraction ────────────────────────────────────────────────
+
+const MAX_MESSAGES_PER_FILE = 3;
+
+function extractMessages(
+  diagnostics: ReadonlyArray<Pick<Diagnostic, "severity" | "message" | "source" | "range">>,
+): HealthDiagnosticMessage[] {
+  const errorsAndWarnings = diagnostics
+    .filter((d) => (d.severity ?? 1) <= 2)
+    .sort(
+      (a, b) => (a.severity ?? 1) - (b.severity ?? 1) || a.range.start.line - b.range.start.line,
+    );
+
+  return errorsAndWarnings.slice(0, MAX_MESSAGES_PER_FILE).map((d) => ({
+    line: d.range.start.line + 1,
+    severity: (d.severity ?? 1) === 1 ? ("error" as const) : ("warning" as const),
+    message: typeof d.message === "string" ? d.message : d.message.value,
+    ...(d.source ? { source: d.source } : {}),
+  }));
+}
+
+export function unavailableDiagnostics(
+  scope: HealthDiagnosticScope,
+  reason: string,
+  evidence: DiagnosticEvidenceSummary = emptyEvidence(),
+  scopeStatus?: FileScopeDecision | null,
+): HealthDiagnosticObservation {
+  return {
+    kind: "unavailable",
+    scope,
+    entries: [],
+    evidence,
+    reason,
+    ...(scopeStatus ? { scopeStatus } : {}),
+  };
+}
+
+export function unavailableFileEvidence(file: string): DiagnosticEvidenceSummary {
+  return singleFileEvidence(file, existsSync(file) ? "failed" : "removed");
+}
+
+export function singleFileEvidence(
+  file: string,
+  status: DiagnosticEvidenceDocument["status"],
+): DiagnosticEvidenceSummary {
+  return {
+    requested: 1,
+    confirmed: status === "confirmed" ? 1 : 0,
+    unconfirmed: status === "unconfirmed" ? 1 : 0,
+    failed: status === "failed" ? 1 : 0,
+    removed: status === "removed" ? 1 : 0,
+    documents: [{ file, status }],
+  };
+}
+
+function emptyEvidence(): DiagnosticEvidenceSummary {
+  return {
+    requested: 0,
+    confirmed: 0,
+    unconfirmed: 0,
+    failed: 0,
+    removed: 0,
+    documents: [],
+  };
+}
+
+function hasIssueCounts(errors: number, warnings: number): boolean {
+  return errors > 0 || warnings > 0;
+}
+
+function errorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error && error.message ? error.message : fallback;
+}

package/src/analysis/health/recovery.ts

@@ -2,7 +2,11 @@
 // Extracted from orchestrate.ts.
 
 import type { CapabilityState, CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
-import type { RecoverDiagnosticsResult, WorkspaceLspRuntime } from "@mrclrchtr/supi-lsp/api";
+import type {
+  DiagnosticEvidenceSummary,
+  RecoverDiagnosticsResult,
+  WorkspaceLspRuntime,
+} from "@mrclrchtr/supi-lsp/api";
 
 // ── Recovery ──────────────────────────────────────────────────────────
 
@@ -10,6 +14,8 @@ interface RecoverOptions {
   service: WorkspaceLspRuntime;
   progress?: () => void;
   control?: CodeRequestControl;
+  /** Evidence from the maintenance refresh, so the recovery pass skips its own refresh. */
+  initialEvidence?: DiagnosticEvidenceSummary;
 }
 
 /** Run the runtime's best-effort recovery and preserve its established outcome. */
@@ -19,6 +25,7 @@ export async function recoverDiagnosticRuntime(
   opts.progress?.();
   return opts.service.recoverDiagnostics({
     restartIfStillStale: true,
+    ...(opts.initialEvidence !== undefined ? { initialEvidence: opts.initialEvidence } : {}),
     control: opts.control,
   });
 }

package/src/analysis/readiness.ts

@@ -12,6 +12,10 @@ import {
 
 export const DEFAULT_SEMANTIC_STARTUP_TIMEOUT_MS = 15_000;
 
+/** Neutral reason for a typed semantic readiness timeout. */
+export const SEMANTIC_READINESS_TIMEOUT_REASON =
+  "Semantic provider did not become ready within the wait window; retry shortly.";
+
 export type SemanticStartupScope = { kind: "workspace" } | { kind: "file"; file: string };
 
 export async function ensureSemanticReadiness(

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

@@ -5,7 +5,7 @@ import {
   getSupportedExtensions,
   type StructuralSearchOperation,
 } from "@mrclrchtr/supi-tree-sitter/api";
-import { type DeadlineOutcome, settleByDeadline } from "./deadline.ts";
+import { type DeadlineOutcome, type ScheduleDeadline, settleByDeadline } from "./deadline.ts";
 import { relativeDisplayPath } from "./paths.ts";
 
 /** Directory names excluded below an AST Scan root. */
@@ -83,6 +83,8 @@ export interface EnumerateAstFilesOptions {
   readonly timeoutMs?: number;
   readonly signal?: AbortSignal;
   readonly now?: () => number;
+  /** Timer seam for deterministic deadline tests; defaults to wall-clock timers. */
+  readonly schedule?: ScheduleDeadline;
   readonly operations?: AstScanOperations;
 }
 
@@ -302,6 +304,7 @@ class AstFileEnumerator {
       deadline: this.options.deadline,
       now: this.#now,
       signal: this.options.signal,
+      schedule: this.options.schedule,
     });
     if (outcome.kind === "timeout") this.#markTimeout();
     return outcome;

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

@@ -6,10 +6,10 @@ import {
   type OutlineData,
   type StructuralProvider as StructuralSubstrate,
 } from "@mrclrchtr/supi-code-runtime/api";
-import type { CodeFindAstKind } from "../../tool/find/ast-kinds.ts";
+import type { CodeFindAstKind } from "../../tool/code_find/ast-kinds.ts";
 import type { AstScanLimitation } from "./ast-scan.ts";
 import { callableExpressionForMatching } from "./call-name.ts";
-import { type DeadlineOutcome, settleByDeadline } from "./deadline.ts";
+import { type DeadlineOutcome, type ScheduleDeadline, settleByDeadline } from "./deadline.ts";
 import { relativeDisplayPath } from "./paths.ts";
 
 export interface StructuredPatternParams {
@@ -55,6 +55,8 @@ interface AnalyzeStructuredFilesOptions {
   readonly deadline: number;
   readonly now: () => number;
   readonly signal?: AbortSignal;
+  /** Timer seam for deterministic deadline tests; defaults to wall-clock timers. */
+  readonly schedule?: ScheduleDeadline;
   readonly requestControl: CodeRequestControl;
   readonly initialLimitations: readonly AstScanLimitation[];
 }
@@ -101,7 +103,12 @@ export async function analyzeStructuredFiles(
             });
           }
         },
-        { deadline: options.deadline, now: options.now, signal: options.signal },
+        {
+          deadline: options.deadline,
+          now: options.now,
+          signal: options.signal,
+          schedule: options.schedule,
+        },
       );
     } catch (error) {
       if (!isCodeRequestDeadlineError(error)) throw error;