@mrclrchtr/supi-code-intelligence 6.1.0 → 6.2.0

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/scope.ts

@@ -0,0 +1,138 @@
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import { extractBindingIdentifiers } from "./js-binding-pattern.ts";
+
+/** Return the declared name for one executable syntax scope. */
+export function extractScopeName(node: SyntaxNodeLike): string {
+  const declaredName = findDeclaredName(node);
+  if (declaredName) return declaredName;
+
+  if (node.type === "arrow_function" || node.type === "function_expression") {
+    const binding = findNearestJavaScriptBinding(node);
+    if (binding) return binding;
+  }
+
+  if (node.type === "function_definition") {
+    const binding = findNearestRBinding(node);
+    if (binding) return binding;
+  }
+
+  return "anonymous";
+}
+
+function findDeclaredName(node: SyntaxNodeLike): string | null {
+  const name = node.childForFieldName("name");
+  if (name && isNameNode(name)) return name.text;
+
+  const declarator = node.childForFieldName("declarator");
+  return declarator ? findDeclaratorName(declarator) : null;
+}
+
+function findDeclaratorName(node: SyntaxNodeLike): string | null {
+  const namedChild = node.childForFieldName("name");
+  if (namedChild && isNameNode(namedChild)) return namedChild.text;
+  if (isNameNode(node)) return node.text;
+  const nested = node.childForFieldName("declarator");
+  if (nested) {
+    const name = findDeclaratorName(nested);
+    if (name) return name;
+  }
+  for (const child of node.children) {
+    const name = findDeclaratorName(child);
+    if (name) return name;
+  }
+  return null;
+}
+
+function findNearestJavaScriptBinding(node: SyntaxNodeLike): string | null {
+  for (let current = node.parent; current; current = current.parent) {
+    const binding = bindingForJavaScriptAncestor(current, node);
+    if (binding) return binding;
+  }
+  return null;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: binding lookup covers the grammar's distinct assignment and object-pattern forms
+function bindingForJavaScriptAncestor(node: SyntaxNodeLike, target: SyntaxNodeLike): string | null {
+  if (node.type === "variable_declarator") {
+    return isDirectValue(node, target)
+      ? (extractBindingIdentifiers(node.childForFieldName("name"))[0] ?? null)
+      : null;
+  }
+  if (node.type === "pair_pattern") {
+    return isDirectValue(node, target)
+      ? (extractBindingIdentifiers(node.childForFieldName("value"))[0] ??
+          node.childForFieldName("key")?.text ??
+          null)
+      : null;
+  }
+  if (node.type === "pair") {
+    return isDirectValue(node, target) ? (node.childForFieldName("key")?.text ?? null) : null;
+  }
+  if (node.type === "assignment_expression") {
+    const right = node.childForFieldName("right");
+    if (!sameNode(right, target)) return null;
+    const left = node.childForFieldName("left");
+    return left
+      ? (extractBindingIdentifiers(left)[0] ??
+          (left.type === "member_expression" || left.type === "subscript_expression"
+            ? left.text
+            : null))
+      : null;
+  }
+  if (node.type === "public_field_definition") {
+    return isDirectValue(node, target)
+      ? ((node.childForFieldName("name") ?? node.childForFieldName("key"))?.text ?? null)
+      : null;
+  }
+  return null;
+}
+
+function isDirectValue(node: SyntaxNodeLike, target: SyntaxNodeLike): boolean {
+  return sameNode(node.childForFieldName("value"), target);
+}
+
+function findNearestRBinding(node: SyntaxNodeLike): string | null {
+  for (let current = node.parent; current; current = current.parent) {
+    const binding = bindingForRAncestor(current, node);
+    if (binding) return binding;
+  }
+  return null;
+}
+
+function bindingForRAncestor(node: SyntaxNodeLike, target: SyntaxNodeLike): string | null {
+  if (node.type !== "binary_operator") return null;
+  const right = node.childForFieldName("rhs") ?? node.childForFieldName("right");
+  const left = node.childForFieldName("lhs") ?? node.childForFieldName("left");
+  return right && left && sameNode(right, target) && left.type === "identifier" ? left.text : null;
+}
+
+function sameNode(left: SyntaxNodeLike | null, right: SyntaxNodeLike): boolean {
+  if (!left) return false;
+  return (
+    left.type === right.type &&
+    left.startPosition.row === right.startPosition.row &&
+    left.startPosition.column === right.startPosition.column &&
+    left.endPosition.row === right.endPosition.row &&
+    left.endPosition.column === right.endPosition.column
+  );
+}
+
+const NAME_NODE_TYPES = new Set([
+  "identifier",
+  "type_identifier",
+  "field_identifier",
+  "property_identifier",
+  "private_property_identifier",
+  "simple_identifier",
+  "word",
+  "constant",
+  "scope_resolution",
+  "qualified_identifier",
+  "template_function",
+  "operator_name",
+  "destructor_name",
+]);
+
+function isNameNode(node: SyntaxNodeLike): boolean {
+  return NAME_NODE_TYPES.has(node.type);
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/types.ts

@@ -128,13 +128,6 @@ export interface TreeSitterSession extends TreeSitterService {
   dispose(): Promise<void>;
 }
 
-/** Session-scoped shared structural service published by the extension runtime. */
-export type SessionTreeSitterService = TreeSitterService;
-
-export type SessionTreeSitterServiceState =
-  | { kind: "ready"; service: SessionTreeSitterService }
-  | { kind: "unavailable"; reason: string };
-
 /** Supported grammar identifiers. */
 export type GrammarId =
   | "javascript"

package/node_modules/@mrclrchtr/supi-tree-sitter/src/worker/parsed-file-store.ts

@@ -196,10 +196,8 @@ export class ParsedFileStore {
   withQuery<T>(
     grammarId: GrammarId,
     queryText: string,
-    compileOrExecution: (() => Query) | QueryExecution<T>,
-    legacyExecute?: (query: Pick<Query, "matches">, cache: StructuralCacheObservation) => T,
+    execution: QueryExecution<T>,
   ): { readonly data: T; readonly cache: StructuralCacheObservation } {
-    const execution = normalizeQueryExecution(compileOrExecution, legacyExecute);
     this.#assertActive();
     throwIfStructuralRequestInterrupted(execution.control);
     const key = queryKey(grammarId, queryText);
@@ -365,17 +363,6 @@ export class ParsedFileStore {
   }
 }
 
-function normalizeQueryExecution<T>(
-  compileOrExecution: (() => Query) | QueryExecution<T>,
-  legacyExecute:
-    | ((query: Pick<Query, "matches">, cache: StructuralCacheObservation) => T)
-    | undefined,
-): QueryExecution<T> {
-  if (typeof compileOrExecution !== "function") return compileOrExecution;
-  if (!legacyExecute) throw new Error("Query execution callback is required");
-  return { compile: compileOrExecution, execute: legacyExecute };
-}
-
 function fileReadMessage(error: unknown): string {
   return error instanceof Error ? error.message : "File could not be read";
 }

package/node_modules/@mrclrchtr/supi-tree-sitter/src/worker/runtime.ts

@@ -372,16 +372,6 @@ export class TreeSitterRuntime {
     }
   }
 
-  /** Get the grammar ID for a file, or undefined if unsupported. */
-  getGrammarId(filePath: string): GrammarId | undefined {
-    return detectGrammar(filePath);
-  }
-
-  /** Resolve a file path from cwd. */
-  resolvePath(filePath: string): string {
-    return resolveToolPath(this.cwd, filePath);
-  }
-
   /** Dispose all held tree, query, and parser resources. */
   dispose(): void {
     if (this.disposed) return;

package/node_modules/@mrclrchtr/supi-tree-sitter/src/worker/service.ts

@@ -1,14 +1,12 @@
 import { detectGrammar } from "../language.ts";
 import { supportsGrammarOperation } from "../operation-support.ts";
 import type { StructuralWorkerOperation } from "../session/structural-worker-protocol.ts";
-import {
-  extractCallSites,
-  extractExports,
-  extractImports,
-  extractOutline,
-  lookupCalleesAt,
-  lookupNodeAt,
-} from "../tool/structure.ts";
+import { extractCallSites } from "../tool/call-sites.ts";
+import { lookupCalleesAt } from "../tool/callees.ts";
+import { extractExports } from "../tool/exports.ts";
+import { extractImports } from "../tool/imports.ts";
+import { lookupNodeAt } from "../tool/node-at.ts";
+import { collectOutline as extractOutline } from "../tool/outline.ts";
 import type { TreeSitterResult } from "../types.ts";
 import {
   type StructuralRequestControl,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/worker/worker-main.ts

@@ -4,11 +4,11 @@ import type { StructuralTimingEvent } from "../session/structural-timing.ts";
 import { assertStructuralProtocolMessageSize } from "../session/structural-worker-message-size.ts";
 import {
   encodeStructuralResult,
-  type ParentToStructuralWorkerMessage,
+  getStructuralWorkerMessageGeneration,
   STRUCTURAL_WORKER_PROTOCOL_VERSION,
   type StructuralWorkerChunkAckMessage,
   type StructuralWorkerRequestMessage,
-  validateStructuralWorkerRequest,
+  validateParentToStructuralWorkerMessage,
 } from "../session/structural-worker-protocol.ts";
 import type { TreeSitterResult } from "../types.ts";
 import type { StructuralRequestControl } from "./request-control.ts";
@@ -56,21 +56,37 @@ export async function runStructuralWorker(
   };
 
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: protocol dispatch keeps request, cancel, and acknowledgement validation together
-  parentPort.on("message", (message: ParentToStructuralWorkerMessage) => {
-    if (message.version !== STRUCTURAL_WORKER_PROTOCOL_VERSION) return;
+  parentPort.on("message", (value: unknown) => {
+    const validation = validateParentToStructuralWorkerMessage(value);
+    if (validation.kind === "invalid") {
+      const generation = getStructuralWorkerMessageGeneration(value);
+      if (generation !== undefined && generation !== workerData.generation) return;
+      throw new Error(`Structural Worker protocol violation: ${validation.reason}`);
+    }
+
+    const message = validation.message;
     if (message.generation !== workerData.generation) return;
     if (message.kind === "cancel") {
-      if (active?.message.requestId === message.requestId) active.abortController.abort();
+      if (!active) return;
+      assertActiveRequestOwner(active, message.requestId);
+      active.abortController.abort();
       return;
     }
     if (message.kind === "chunk-ack") {
-      if (active?.message.requestId === message.requestId) sendNextChunk(message);
+      if (!active) return;
+      assertActiveRequestOwner(active, message.requestId);
+      if (!active.awaitingAck || message.sequence !== active.nextSequence - 1) {
+        throw new Error(
+          "Structural Worker protocol violation: Invalid chunk acknowledgement state",
+        );
+      }
+      sendNextChunk(message);
       return;
     }
-    if (message.kind !== "request" || active) return;
-    const validation = validateStructuralWorkerRequest(message);
-    if (validation.kind === "invalid") return;
-    void execute(validation.message);
+    if (active) {
+      throw new Error("Structural Worker protocol violation: Structural Worker request is busy");
+    }
+    void execute(message);
   });
 
   try {
@@ -187,6 +203,14 @@ export async function runStructuralWorker(
     active = null;
   }
 
+  function assertActiveRequestOwner(request: ActiveWorkerRequest, requestId: string): void {
+    if (request.message.requestId !== requestId) {
+      throw new Error(
+        "Structural Worker protocol violation: Message does not own the active request",
+      );
+    }
+  }
+
   function updateInterruptionOutcome(request: ActiveWorkerRequest): void {
     if (request.message.deadline !== undefined && Date.now() >= request.message.deadline) {
       request.outcome = "timeout";

package/package.json

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

package/src/analysis/capability/capability-warnings.ts

@@ -1,18 +1,18 @@
 /**
  * Capability Warning evaluation for reduced semantic and structural analysis.
  *
- * Normalizes LSP startup state, Tree-sitter health, and deprecated config keys
- * into a structured report consumed by the startup notice, /supi-ci-status,
+ * Normalizes LSP startup state and Tree-sitter health into a structured report
+ * consumed by the startup notice, /supi-ci-status,
  * and code_health.
  */
 
 import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
 import { loadSupiConfigForScope } from "@mrclrchtr/supi-core/config";
-import { getDeprecatedLspKeys, loadConfig, scanMissingServers } from "@mrclrchtr/supi-lsp/api";
+import { loadConfig, scanMissingServers } from "@mrclrchtr/supi-lsp/api";
 
 /** One actionable warning about reduced Code intelligence capability. */
 export interface CapabilityWarning {
-  type: "deprecated-key" | "language-disabled" | "missing-server" | "structural-unavailable";
+  type: "language-disabled" | "missing-server" | "structural-unavailable";
   message: string;
   language?: string;
   detail?: string;
@@ -31,7 +31,6 @@ export interface CapabilityWarningMissingServerSource {
 
 /** Current runtime/config facts needed to evaluate Capability Warnings. */
 export interface CapabilityWarningInput {
-  deprecatedKeys: ReturnType<typeof getDeprecatedLspKeys>;
   explicitlyDisabledLanguages: string[];
   missingServers: Array<{ name: string; command: string; foundExtensions: string[] }>;
   structuralState: { kind: string; reason?: string };
@@ -41,21 +40,6 @@ export interface CapabilityWarningInput {
 export function evaluateCapabilityWarnings(input: CapabilityWarningInput): CapabilityWarningReport {
   const warnings: CapabilityWarning[] = [];
 
-  if (input.deprecatedKeys.projectEnabled || input.deprecatedKeys.globalEnabled) {
-    warnings.push({
-      type: "deprecated-key",
-      message:
-        "lsp.enabled is deprecated and ignored. Use lsp.servers.<language>.enabled: false for per-language disable.",
-    });
-  }
-  if (input.deprecatedKeys.projectActive || input.deprecatedKeys.globalActive) {
-    warnings.push({
-      type: "deprecated-key",
-      message:
-        "lsp.active is deprecated and ignored. All detected servers are attempted unless explicitly disabled.",
-    });
-  }
-
   for (const language of input.explicitlyDisabledLanguages) {
     warnings.push({
       type: "language-disabled",
@@ -143,7 +127,6 @@ export function gatherCapabilityWarningInput(
   cwd: string,
   lspController: CapabilityWarningMissingServerSource | null,
 ): CapabilityWarningInput {
-  const deprecatedKeys = getDeprecatedLspKeys(cwd);
   const structuralState = getDefaultWorkspaceRuntime().getWorkspace(cwd).structural.state;
   const explicitlyDisabledLanguages = detectExplicitlyDisabledLanguages(cwd);
   const missingServers = lspController
@@ -151,7 +134,6 @@ export function gatherCapabilityWarningInput(
     : scanMissingServers(loadConfig(cwd), cwd);
 
   return {
-    deprecatedKeys,
     explicitlyDisabledLanguages,
     missingServers,
     structuralState,

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

@@ -1,6 +1,8 @@
 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 {
+  startDebugTimer,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import type { StructuralSearchOperation } from "@mrclrchtr/supi-tree-sitter/api";
 import type { StructuredFileAnalysis, StructuredPatternParams } from "./pattern-analysis.ts";
 

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

@@ -150,7 +150,7 @@ export async function enumerateAstFiles(
 class AstFileEnumerator {
   readonly #operations: AstScanOperations;
   readonly #now: () => number;
-  readonly #grammarExtensions = new Set(getSupportedExtensions());
+  readonly #grammarExtensions: ReadonlySet<string> = new Set(getSupportedExtensions());
   readonly #operationExtensions: ReadonlySet<string>;
   readonly #files = new Set<string>();
   readonly #visitedDirectories = new Set<string>();

package/src/api.ts

@@ -48,6 +48,7 @@ export type {
 export type {
   HealthDiagnosticObservation,
   HealthDiagnosticScope,
+  HealthFileReadiness,
   HealthRefreshAttempt,
   HealthRefreshState,
   HealthStaleAssessment,

package/src/extension.ts

@@ -6,8 +6,10 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
-import { truncateIdentity } from "@mrclrchtr/supi-lsp/debug-telemetry";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import { buildArchitectureModel } from "./analysis/architecture/discovery.ts";
 import { createCodeIntelligenceApp } from "./app/app.ts";
 import { registerCodeIntelligenceSettings, resolveOverviewEnabled } from "./config.ts";

package/src/session/health-refresh.ts

@@ -2,11 +2,19 @@ import {
   type CodeRequestControl,
   isCodeRequestInterruption,
 } from "@mrclrchtr/supi-code-runtime/api";
-import type { WorkspaceDiagnosticReport, WorkspaceLspRuntime } from "@mrclrchtr/supi-lsp/api";
+import {
+  emptyProcessCrashRecoverySummary,
+  type WorkspaceDiagnosticReport,
+  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";
+import type {
+  HealthDiagnosticScope,
+  HealthFileReadiness,
+  HealthRefreshAttempt,
+} from "./health-types.ts";
 
 interface HealthRefreshAttemptOptions {
   readonly runtime: WorkspaceLspRuntime;
@@ -51,6 +59,8 @@ async function collectFileRefreshAttempt(
     undefined,
     options.control,
   );
+  const fileReadiness: HealthFileReadiness =
+    readiness.kind === "ready" ? "ready" : readiness.kind === "timeout" ? "pending" : "unavailable";
   return {
     attempt: {
       kind: "completed",
@@ -59,7 +69,9 @@ async function collectFileRefreshAttempt(
       requestedDiagnosticScope: scope,
       operationScope: "file-runtime",
       attemptedActiveClients: readiness.kind === "ready" ? 1 : 0,
+      fileReadiness,
       restartedClients: 0,
+      processCrashRecovery: readiness.processCrashRecovery ?? emptyProcessCrashRecoverySummary(),
       staleAssessment: {
         scope: "file",
         suspected: null,
@@ -126,7 +138,16 @@ async function collectWorkspaceRefreshAttempt(
           elapsedMs: Date.now() - options.attemptedAt,
           requestedDiagnosticScope: options.diagnosticsScope,
           operationScope: "workspace-runtime",
+          attemptedActiveClients: recovery.attemptedClients,
+          restartedClients: recovery.restartedClients,
+          staleAssessment: {
+            scope: "workspace",
+            suspected: recovery.staleAssessment.suspected,
+            matchedFileCount: recovery.staleAssessment.matchedFiles.length,
+            warning: recovery.staleAssessment.warning,
+          },
           diagnosticEvidence,
+          processCrashRecovery: recovery.processCrashRecovery,
           reason: recovery.refreshFailureReason,
         },
         diagnosticReport: recovery.diagnosticReport,
@@ -141,6 +162,7 @@ async function collectWorkspaceRefreshAttempt(
         operationScope: "workspace-runtime",
         attemptedActiveClients: recovery.attemptedClients,
         restartedClients: recovery.restartedClients,
+        processCrashRecovery: recovery.processCrashRecovery,
         diagnosticEvidence,
         staleAssessment: {
           scope: "workspace",

package/src/session/health-types.ts

@@ -1,6 +1,7 @@
 import type {
   DiagnosticEvidenceSummary,
   FileScopeDecision,
+  ProcessCrashRecoverySummary,
   ProjectServerInfo,
   ProjectServerStatusReason,
 } from "@mrclrchtr/supi-lsp/api";
@@ -93,6 +94,9 @@ export interface HealthStaleAssessment {
 
 export type HealthRefreshOperationScope = "file-runtime" | "workspace-runtime";
 
+/** Readiness result for a file-scoped maintenance attempt. */
+export type HealthFileReadiness = "ready" | "pending" | "unavailable";
+
 /** Shared facts for one completed refresh or file-maintenance attempt. */
 interface CompletedHealthRefreshAttempt {
   readonly kind: "completed";
@@ -103,7 +107,12 @@ interface CompletedHealthRefreshAttempt {
   readonly requestedDiagnosticScope: HealthDiagnosticScope;
   /** Active clients targeted by the best-effort operation; this is not a confirmed-success count. */
   readonly attemptedActiveClients: number;
+  /** File readiness after the bounded wait, when this is file-scoped. */
+  readonly fileReadiness?: HealthFileReadiness;
+  /** Clients restarted by stale-diagnostic recovery. */
   readonly restartedClients: number;
+  /** Separate outcome for process-crash route recovery. */
+  readonly processCrashRecovery: ProcessCrashRecoverySummary;
   readonly staleAssessment: HealthStaleAssessment;
 }
 
@@ -125,8 +134,18 @@ export type HealthRefreshAttempt =
       readonly elapsedMs: number;
       readonly requestedDiagnosticScope: HealthDiagnosticScope;
       readonly operationScope: HealthRefreshOperationScope;
+      /** Active clients targeted before the operation failed, when available. */
+      readonly attemptedActiveClients?: number;
+      /** Clients restarted by stale-diagnostic recovery, when available. */
+      readonly restartedClients?: number;
+      /** Stale-diagnostic assessment, when the recovery pass returned one. */
+      readonly staleAssessment?: HealthStaleAssessment;
       /** Evidence collected before the operation failed, when available. */
       readonly diagnosticEvidence?: DiagnosticEvidenceSummary;
+      /** Process-crash outcome, when the recovery pass returned one. */
+      readonly processCrashRecovery?: ProcessCrashRecoverySummary;
+      /** File readiness outcome, when a file-scoped attempt failed. */
+      readonly fileReadiness?: HealthFileReadiness;
       readonly reason: string;
     };
 

package/src/session/input/health-refactor.ts

@@ -1,11 +1,12 @@
 /** Runtime parsers for health and refactor session workflows. */
 
 import type { HealthSection, HealthWorkflowInput } from "../health-types.ts";
-import type {
-  PublicSourceRange,
-  RefactorApplyWorkflowInput,
-  RefactorOperationInput,
-  RefactorPlanWorkflowInput,
+import {
+  PUBLIC_REFACTOR_OPERATION_NAMES,
+  type PublicSourceRange,
+  type RefactorApplyWorkflowInput,
+  type RefactorOperationInput,
+  type RefactorPlanWorkflowInput,
 } from "../refactor-types.ts";
 import type { RefactorTargetInput } from "../target-input.ts";
 import {
@@ -94,22 +95,23 @@ export function parseRefactorPlanWorkflowInput(
 function parseRefactorOperation(value: unknown): InputValidation<RefactorOperationInput> {
   const record = requireRecord(value, "operation");
   if (record.kind === "invalid-input") return record;
-  const keysError = requireOnlyKeys(
-    record.value,
-    ["rename_symbol", "extract_function", "extract_variable"],
-    "operation",
-  );
+  const keysError = requireOnlyKeys(record.value, PUBLIC_REFACTOR_OPERATION_NAMES, "operation");
   if (keysError) return invalid(keysError);
-  const selected = (["rename_symbol", "extract_function", "extract_variable"] as const).filter(
-    (key) => record.value[key] !== undefined,
-  );
+  const selected = PUBLIC_REFACTOR_OPERATION_NAMES.filter((key) => record.value[key] !== undefined);
   if (selected.length !== 1) return invalid("Select exactly one refactor operation.");
 
   const name = selected[0];
   const payload = requireRecord(record.value[name], `operation.${name}`);
   if (payload.kind === "invalid-input") return payload;
   if (name === "rename_symbol") return parseRenameOperation(payload.value);
-  return parseExtractOperation(name, payload.value);
+  if (name === "extract_function" || name === "extract_variable") {
+    return parseExtractOperation(name, payload.value);
+  }
+  const payloadError = requireOnlyKeys(payload.value, [], `operation.${name}`);
+  if (payloadError) return invalid(payloadError);
+  return name === "update_imports"
+    ? valid({ update_imports: {} })
+    : valid({ delete_dead_code: {} });
 }
 
 function parseRenameOperation(

package/src/session/refactor-types.ts

@@ -3,6 +3,17 @@ import type { ApplyResult } from "../analysis/refactor/apply.ts";
 import type { RefactorPlan } from "./refactor-plans.ts";
 import type { RefactorTargetInput, SourcePointInput } from "./target-input.ts";
 
+/** Public refactor operations exposed by code_refactor_plan. */
+export const PUBLIC_REFACTOR_OPERATION_NAMES = [
+  "rename_symbol",
+  "extract_function",
+  "extract_variable",
+  "update_imports",
+  "delete_dead_code",
+] as const;
+
+export type PublicRefactorOperationName = (typeof PUBLIC_REFACTOR_OPERATION_NAMES)[number];
+
 export interface PublicSourceRange {
   readonly start: Omit<SourcePointInput, "file">;
   readonly end: Omit<SourcePointInput, "file">;
@@ -21,7 +32,9 @@ export type RefactorOperationInput =
         readonly newName: string;
         readonly range: PublicSourceRange;
       };
-    };
+    }
+  | { readonly update_imports: Record<string, never> }
+  | { readonly delete_dead_code: Record<string, never> };
 
 export interface RefactorPlanWorkflowInput {
   readonly target: RefactorTargetInput;