@mrclrchtr/supi-code-intelligence 4.0.0 → 4.2.0

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

@@ -0,0 +1,307 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+/** Extract Ruby, shell, and R declarations from their grammar-specific node shapes. */
+export function extractScriptingOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  const ruby = rubyItems(node, "top-level", source);
+  if (ruby) return ruby;
+
+  switch (node.type) {
+    case "variable_assignment":
+      return isNestedShellDeclaration(node) || node.parent?.type === "command"
+        ? []
+        : one(shellVariable(node, "variable", source));
+    case "declaration_command":
+      return isNestedShellDeclaration(node) ? [] : shellDeclarations(node, source);
+    case "function_definition": {
+      const nameType = node.childForFieldName("name")?.type;
+      if (nameType === "word") {
+        return isNestedShellDeclaration(node) ? [] : one(named(node, "function", source));
+      }
+      return nameType === "function" || nameType === "\\" ? [] : undefined;
+    }
+    case "binary_operator":
+      return rAssignments(node, source);
+    default:
+      return undefined;
+  }
+}
+
+function rubyItems(
+  node: SyntaxNodeLike,
+  context: "top-level" | "member",
+  source: string,
+): OutlineItem[] | undefined {
+  switch (node.type) {
+    case "assignment":
+    case "operator_assignment":
+      return rubyAssignments(node, context, source);
+    case "module":
+      return isRubyContainer(node) ? one(rubyContainer(node, "module", source)) : undefined;
+    case "class":
+      return isRubyContainer(node) ? one(rubyContainer(node, "class", source)) : undefined;
+    case "method":
+      return one(named(node, context === "member" ? "method" : "function", source));
+    case "singleton_method":
+      return one(named(node, "method", source));
+    case "singleton_class":
+      return rubyMembers(node.childForFieldName("body"), source);
+    case "alias":
+      return one(named(node, context === "member" ? "method" : "function", source));
+    case "call":
+      return context === "member" ? rubyCallMethods(node, source) : undefined;
+    case "block":
+      return node.childForFieldName("body")?.type === "block_body" ? [] : undefined;
+    case "do_block":
+      return node.childForFieldName("body")?.type === "body_statement" ? [] : undefined;
+    default:
+      return undefined;
+  }
+}
+
+function isRubyContainer(node: SyntaxNodeLike): boolean {
+  const name = node.childForFieldName("name");
+  const body = node.childForFieldName("body");
+  return Boolean(
+    name && RUBY_CONTAINER_NAME_TYPES.has(name.type) && (!body || body.type === "body_statement"),
+  );
+}
+
+function rubyContainer(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: rubyMembers(node.childForFieldName("body"), source),
+  };
+}
+
+function rubyMembers(body: SyntaxNodeLike | null | undefined, source: string): OutlineItem[] {
+  if (!body) return [];
+  return body.children.flatMap((child) => rubyItems(child, "member", source) ?? []);
+}
+
+function rubyAssignments(
+  node: SyntaxNodeLike,
+  context: "top-level" | "member",
+  source: string,
+): OutlineItem[] {
+  const left = node.childForFieldName("left");
+  if (!left) return [];
+  const range = nodeToRange(node, source);
+  const items = rubyBindingNodes(left)
+    .filter((binding) => context === "top-level" || binding.type !== "identifier")
+    .map((binding) => ({
+      name: binding.text,
+      kind:
+        binding.type === "constant" || binding.type === "scope_resolution"
+          ? "constant"
+          : "variable",
+      range,
+    }));
+  const right = unwrapParentheses(node.childForFieldName("right"));
+  const chained =
+    right?.type === "assignment" || right?.type === "operator_assignment"
+      ? rubyAssignments(right, context, source)
+      : [];
+  return [...items, ...chained];
+}
+
+function rubyBindingNodes(node: SyntaxNodeLike): SyntaxNodeLike[] {
+  if (RUBY_BINDING_TYPES.has(node.type)) return [node];
+  if (!RUBY_BINDING_PATTERNS.has(node.type)) return [];
+  return node.children.flatMap(rubyBindingNodes);
+}
+
+function rubyCallMethods(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const method = node.childForFieldName("method")?.text;
+  const argumentsNode = node.childForFieldName("arguments");
+  if (!method || !argumentsNode || node.childForFieldName("receiver")) return undefined;
+
+  if (RUBY_ATTRIBUTE_METHODS.has(method)) {
+    const range = nodeToRange(node, source);
+    return rubySymbolNames(argumentsNode).flatMap((name) => {
+      if (method === "attr_writer") return [{ name: `${name}=`, kind: "method", range }];
+      if (method === "attr_accessor") {
+        return [
+          { name, kind: "method", range },
+          { name: `${name}=`, kind: "method", range },
+        ];
+      }
+      return [{ name, kind: "method", range }];
+    });
+  }
+  if (method === "alias_method") {
+    const name = rubySymbolNames(argumentsNode)[0];
+    return name ? [{ name, kind: "method", range: nodeToRange(node, source) }] : [];
+  }
+  if (RUBY_VISIBILITY_METHODS.has(method)) {
+    const declaration = argumentsNode.children.find(
+      (child) => child.type === "method" || child.type === "singleton_method",
+    );
+    return declaration ? rubyItems(declaration, "member", source) : [];
+  }
+  return undefined;
+}
+
+function rubySymbolNames(node: SyntaxNodeLike): string[] {
+  return node.children
+    .filter((child) => child.type === "simple_symbol")
+    .map((child) => child.text.replace(/^:/, ""));
+}
+
+function isNestedShellDeclaration(node: SyntaxNodeLike): boolean {
+  if (isBackgroundedShellNode(node)) return true;
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (SHELL_SCOPE_BOUNDARIES.has(parent.type)) return true;
+  }
+  return false;
+}
+
+function isBackgroundedShellNode(node: SyntaxNodeLike): boolean {
+  for (let current = node, parent = node.parent; parent; current = parent, parent = parent.parent) {
+    const index = parent.children.findIndex((child) => sameNode(child, current));
+    if (index >= 0 && parent.children[index + 1]?.type === "&") return true;
+  }
+  return false;
+}
+
+function sameNode(left: SyntaxNodeLike, right: SyntaxNodeLike): boolean {
+  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
+  );
+}
+
+function shellVariable(
+  node: SyntaxNodeLike,
+  kind: "constant" | "variable",
+  source: string,
+): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name?.type === "variable_name"
+    ? { name: name.text, kind, range: nodeToRange(node, source) }
+    : null;
+}
+
+function shellDeclarations(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  if (node.children.some((child) => child.type === "word" && /^-[a-z]*[pf]/i.test(child.text))) {
+    return [];
+  }
+  const constant =
+    node.children.some((child) => child.type === "readonly") ||
+    node.children.some((child) => child.type === "word" && /^-[a-z]*r/i.test(child.text));
+  const range = nodeToRange(node, source);
+  return node.children.flatMap((child) => {
+    if (child.type === "variable_assignment") {
+      const item = shellVariable(child, constant ? "constant" : "variable", source);
+      return item ? [{ ...item, range }] : [];
+    }
+    return child.type === "variable_name"
+      ? [{ name: child.text, kind: constant ? "constant" : "variable", range }]
+      : [];
+  });
+}
+
+function rAssignments(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const operator = node.children.find((child) => R_ASSIGNMENT_OPERATORS.has(child.type))?.type;
+  if (!operator) return undefined;
+
+  const leftward = operator === "=" || operator.endsWith("<-");
+  const receiver = node.childForFieldName(leftward ? "lhs" : "rhs");
+  const value = node.childForFieldName(leftward ? "rhs" : "lhs");
+  if (!receiver || !value) return [];
+
+  const item =
+    receiver.type === "identifier"
+      ? [
+          {
+            name: receiver.text,
+            kind: rAssignedValue(value)?.type === "function_definition" ? "function" : "variable",
+            range: nodeToRange(node, source),
+          },
+        ]
+      : [];
+  const nestedAssignment = unwrapParentheses(value);
+  const chained =
+    nestedAssignment?.type === "binary_operator"
+      ? (rAssignments(nestedAssignment, source) ?? [])
+      : [];
+  return [...item, ...chained];
+}
+
+function unwrapParentheses(node: SyntaxNodeLike | null): SyntaxNodeLike | null {
+  if (node?.type === "parenthesized_expression") {
+    return unwrapParentheses(node.childForFieldName("body"));
+  }
+  if (node?.type === "parenthesized_statements") {
+    return unwrapParentheses(
+      node.children.find(
+        (child) => child.type === "assignment" || child.type === "operator_assignment",
+      ) ?? null,
+    );
+  }
+  return node;
+}
+
+function rAssignedValue(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  const assignment = unwrapParentheses(node);
+  if (assignment?.type !== "binary_operator") return assignment;
+
+  const operator = assignment.children.find((child) =>
+    R_ASSIGNMENT_OPERATORS.has(child.type),
+  )?.type;
+  if (!operator) return assignment;
+  const leftward = operator === "=" || operator.endsWith("<-");
+  const value = assignment.childForFieldName(leftward ? "rhs" : "lhs");
+  return value ? rAssignedValue(value) : null;
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+function named(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+}
+
+const RUBY_BINDING_TYPES = new Set([
+  "constant",
+  "identifier",
+  "global_variable",
+  "class_variable",
+  "instance_variable",
+  "scope_resolution",
+]);
+const RUBY_BINDING_PATTERNS = new Set([
+  "left_assignment_list",
+  "destructured_left_assignment",
+  "rest_assignment",
+]);
+const RUBY_CONTAINER_NAME_TYPES = new Set(["constant", "scope_resolution"]);
+const RUBY_ATTRIBUTE_METHODS = new Set(["attr", "attr_reader", "attr_writer", "attr_accessor"]);
+const RUBY_VISIBILITY_METHODS = new Set([
+  "private",
+  "protected",
+  "public",
+  "module_function",
+  "private_class_method",
+  "public_class_method",
+]);
+const SHELL_SCOPE_BOUNDARIES = new Set([
+  "command_substitution",
+  "process_substitution",
+  "subshell",
+  "pipeline",
+]);
+const R_ASSIGNMENT_OPERATORS = new Set(["=", "<-", "<<-", "->", "->>"]);

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

@@ -3,6 +3,7 @@
 import { nodeToRange } from "../coordinates.ts";
 import type { SyntaxNodeLike } from "../syntax-node.ts";
 import type { OutlineItem } from "../types.ts";
+import { extractPolyglotOutlineItems } from "./outline-polyglot.ts";
 
 /** Node types that can be extracted directly as outline items. */
 const OUTLINE_DECLARATION_NODE_TYPES = new Set([
@@ -32,12 +33,15 @@ function collectItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
   const items: OutlineItem[] = [];
 
   for (const child of node.children) {
-    const item = extractItem(child, source);
-    if (item) {
-      items.push(item);
-    } else {
-      items.push(...collectItems(child, source));
+    const polyglotItems = extractPolyglotOutlineItems(child, source);
+    if (polyglotItems) {
+      items.push(...polyglotItems);
+      continue;
     }
+
+    const item = extractItem(child, source);
+    if (item) items.push(item);
+    else items.push(...collectItems(child, source));
   }
 
   return items;

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

@@ -79,7 +79,10 @@ export interface TreeSitterService {
   canParse(file: string): Promise<TreeSitterResult<{ file: string; language: string }>>;
   /** Run a Tree-sitter query and return all captures. */
   query(file: string, queryString: string): Promise<TreeSitterResult<QueryCapture[]>>;
-  /** Extract top-level declarations plus supported class/interface/enum members. */
+  /**
+   * Extract shallow declarations, including supported nested code members,
+   * HTML ids, and SQL schema members.
+   */
   outline(file: string): Promise<TreeSitterResult<OutlineItem[]>>;
   /** Extract static ES import declarations. */
   imports(file: string): Promise<TreeSitterResult<ImportRecord[]>>;
@@ -143,7 +146,6 @@ export type SupportedExtension =
   | ".pyi"
   | ".rs"
   | ".go"
-  | ".mod"
   | ".c"
   | ".h"
   | ".cpp"
@@ -157,9 +159,11 @@ export type SupportedExtension =
   | ".kt"
   | ".kts"
   | ".rb"
+  | ".gemspec"
   | ".sh"
   | ".bash"
   | ".zsh"
+  | ".ksh"
   | ".html"
   | ".htm"
   | ".xhtml"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "SuPi Code Intelligence extension — workspace orientation, target resolution and inspection, relationship analysis, code-aware search, live health, and semantic refactoring for pi",
   "license": "MIT",
   "repository": {
@@ -34,10 +34,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-code-runtime": "4.0.0",
-    "@mrclrchtr/supi-lsp": "4.0.0",
-    "@mrclrchtr/supi-core": "4.0.0",
-    "@mrclrchtr/supi-tree-sitter": "4.0.0"
+    "@mrclrchtr/supi-code-runtime": "4.2.0",
+    "@mrclrchtr/supi-lsp": "4.2.0",
+    "@mrclrchtr/supi-tree-sitter": "4.2.0",
+    "@mrclrchtr/supi-core": "4.2.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",
@@ -77,6 +77,7 @@
     ".": "./src/index.ts",
     "./api": "./src/api.ts",
     "./extension": "./src/extension.ts",
+    "./headless": "./src/headless.ts",
     "./package.json": "./package.json"
   }
 }

package/src/analysis/search/pattern.ts

@@ -344,7 +344,7 @@ async function collectMatchesForFile(
   const outline = await structural.outline(relFile);
   if (!handleStructuralResult(outline, recordFailure)) return;
   for (const item of flattenOutlineItems(outline.data)) {
-    if (kind === "type" && !TYPE_LIKE_KINDS.has(item.kind.toLowerCase())) continue;
+    if (kind === "type" && !TYPE_KIND.test(item.kind.toLowerCase())) continue;
     if (kind === "interface" && item.kind.toLowerCase() !== "interface") continue;
     if (kind === "class" && item.kind.toLowerCase() !== "class") continue;
     if (kind === "method" && item.kind.toLowerCase() !== "method") continue;
@@ -368,7 +368,7 @@ function handleStructuralResult<T>(
   return false;
 }
 
-const TYPE_LIKE_KINDS = new Set(["class", "interface", "type", "enum"]);
+const TYPE_KIND = /^(?:class|interface|type|enum|struct|union|record|object|concept)$/;
 
 const AST_KIND_OPERATIONS = {
   definition: "outline",

package/src/analysis/target/symbol.ts

@@ -117,7 +117,10 @@ export async function resolveSymbolTarget(
     };
   }
   if (result.data.length === 0) {
-    return { kind: "error", message: `Symbol not found: \`${symbol}\`` };
+    return {
+      kind: "error",
+      message: `Symbol not found: \`${symbol}\`. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
+    };
   }
 
   const scopePath = options?.path ? normalizePath(options.path, cwd) : null;
@@ -130,7 +133,7 @@ export async function resolveSymbolTarget(
   if (eligible.length === 0) {
     return {
       kind: "error",
-      message: `Symbol not found: \`${symbol}\`${scopePath ? ` in path \`${options?.path}\`` : ""}`,
+      message: `Symbol not found: \`${symbol}\`${scopePath ? ` in path \`${options?.path}\`` : ""}. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
     };
   }
 

package/src/app/app.ts

@@ -61,7 +61,10 @@ export function createSessionCache(): {
   const sessions = new Map<string, WorkspaceCodeIntelligenceSession>();
   return {
     getOrCreate: (cwd) => getOrCreateSession(sessions, cwd),
-    clear: () => sessions.clear(),
+    clear: () => {
+      for (const session of sessions.values()) session.clearStores();
+      sessions.clear();
+    },
   };
 }
 

package/src/extension.ts

@@ -1,5 +1,5 @@
 // Code Intelligence extension entry point — registers the focused code-intelligence tools,
-// LSP diagnostics and settings, and the unified /supi-ci-status command.
+// shared provider lifecycle, settings, UI, and the unified /supi-ci-status command.
 
 import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildArchitectureModel } from "./analysis/architecture/discovery.ts";
@@ -10,10 +10,6 @@ import { registerLspSessionLifecycle } from "./substrate/lsp/lifecycle.ts";
 import { registerWorkspaceRecoveryHandler } from "./substrate/lsp/recovery.ts";
 import { registerLspSettings } from "./substrate/lsp/settings.ts";
 import { createLspAdapterState } from "./substrate/lsp/state.ts";
-import {
-  createTsAdapterState,
-  registerTsSessionLifecycle,
-} from "./substrate/tree-sitter/lifecycle.ts";
 import { registerCodeIntelligenceTools } from "./tool/register.ts";
 import { registerLspFooterContribution } from "./ui/footer.ts";
 import { estimateTokens, OVERVIEW_TOKEN_BUDGET, renderOverview } from "./ui/markdown/overview.ts";
@@ -21,102 +17,44 @@ import { buildOverviewData } from "./ui/markdown/overview-data.ts";
 import { registerCiStatusCommand } from "./ui/status-command.ts";
 
 const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
-const PROCESS_EXIT_SAFETY_NET = Symbol.for("supi-code-intelligence/process-exit-safety-net");
-
-interface ProcessExitSafetyNet {
-  cleanup: (() => void) | null;
-  handlerRegistered: boolean;
-  handler: () => void;
-}
-
-/**
- * Keep one process-exit listener across `/reload` extension instances.
- * Pi hosts one active extension API per process; replacing its cleanup callback
- * prevents old adapter state from being retained after reload.
- */
-function registerProcessExitSafetyNet(cleanup: () => void): () => void {
-  const host = globalThis as Record<symbol, ProcessExitSafetyNet | undefined>;
-  const safetyNet = host[PROCESS_EXIT_SAFETY_NET] ?? createProcessExitSafetyNet();
-  host[PROCESS_EXIT_SAFETY_NET] = safetyNet;
-
-  safetyNet.cleanup = cleanup;
-  if (!safetyNet.handlerRegistered) {
-    process.once("exit", safetyNet.handler);
-    safetyNet.handlerRegistered = true;
-  }
-
-  return () => {
-    if (safetyNet.cleanup !== cleanup) return;
-    safetyNet.cleanup = null;
-    if (!safetyNet.handlerRegistered) return;
-    process.off("exit", safetyNet.handler);
-    safetyNet.handlerRegistered = false;
-  };
-}
-
-function createProcessExitSafetyNet(): ProcessExitSafetyNet {
-  const safetyNet: ProcessExitSafetyNet = {
-    cleanup: null,
-    handlerRegistered: false,
-    handler: () => {},
-  };
-  safetyNet.handler = () => {
-    safetyNet.handlerRegistered = false;
-    const activeCleanup = safetyNet.cleanup;
-    safetyNet.cleanup = null;
-    activeCleanup?.();
-  };
-  return safetyNet;
-}
 
+/** Register the full interactive Code Intelligence profile. */
 export default function codeIntelligenceExtension(
   pi: ExtensionAPI,
   getOrCreateSession?: (cwd: string) => WorkspaceCodeIntelligenceSession,
 ) {
   const app = createCodeIntelligenceApp(pi);
-
   const lspState = createLspAdapterState();
-  const tsState = createTsAdapterState();
 
-  // ── Substrate wiring ──────────────────────────────────────────────
   registerCodeIntelligenceSettings(pi);
   registerLspSettings(pi);
-  registerLspSessionLifecycle(pi, lspState);
-  registerWorkspaceRecoveryHandler(pi, lspState);
-  registerTsSessionLifecycle(pi, tsState);
-
-  // ── Attach controller refs to sessions on startup (ADR 0008) ──────
-  pi.on("session_start", (_event, ctx) => {
+  registerLspSessionLifecycle(pi, lspState, (ctx) => {
     const session = app.getSession(ctx.cwd);
     if (!session) return;
     session.attachLspController(lspState.controller);
     session.seedSentinelSnapshot(lspState.sentinelSnapshot);
     session.setProjectTrusted(ctx.isProjectTrusted());
   });
+  registerWorkspaceRecoveryHandler(pi, lspState);
 
-  // ── Tool registration ─────────────────────────────────────────────
   registerCodeIntelligenceTools(
     pi,
     getOrCreateSession ?? ((cwd) => app.getSession(cwd) ?? app.createSession(cwd)),
   );
 
-  // ── UI registration ───────────────────────────────────────────────
   registerCiStatusCommand(pi);
   registerLspFooterContribution(lspState);
 
-  // ── Native context path capture for instruction-file dedup ─────────
   pi.on("before_agent_start", (event, ctx) => {
     const session = app.getSession(ctx.cwd) ?? app.createSession(ctx.cwd);
     session.captureNativeInstructionPaths(event.systemPromptOptions.contextFiles ?? []);
   });
 
-  // ── Overview injection — uses the app-managed session state ────────
   pi.on(
     "before_agent_start",
     async (_event, ctx): Promise<BeforeAgentStartEventResult | undefined> => {
       const session = app.getSession(ctx.cwd);
-      if (!session) return;
-      if (!session.claimOverviewInjection()) return;
+      if (!session?.claimOverviewInjection()) return;
 
       const model = await buildArchitectureModel(ctx.cwd);
       if (model.modules.length === 0) return;
@@ -138,24 +76,8 @@ export default function codeIntelligenceExtension(
       }
 
       return {
-        message: {
-          customType: OVERVIEW_CUSTOM_TYPE,
-          display: false,
-          content: overview,
-        },
+        message: { customType: OVERVIEW_CUSTOM_TYPE, display: false, content: overview },
       };
     },
   );
-
-  // ── Process-exit safety net ─────────────────────────────────────────
-  let cleaningUp = false;
-  const unregisterExitSafetyNet = registerProcessExitSafetyNet(() => {
-    if (cleaningUp) return;
-    cleaningUp = true;
-    // Exit handlers cannot await. Controller shutdown begins synchronous
-    // process cleanup before its first await.
-    void lspState.controller?.shutdown();
-    void tsState.controller?.shutdown();
-  });
-  pi.on("session_shutdown", unregisterExitSafetyNet);
 }

package/src/headless.ts

@@ -0,0 +1,41 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createSessionCache } from "./app/app.ts";
+import { registerLspSessionLifecycle } from "./substrate/lsp/lifecycle.ts";
+import { createLspAdapterState } from "./substrate/lsp/state.ts";
+import { registerCodeIntelligenceTools } from "./tool/register.ts";
+import { CODE_INTELLIGENCE_TOOL_SPECS } from "./tool/specs.ts";
+
+/** Exact Code Intelligence tool surface available to managed Reviewer Sessions. */
+export const HEADLESS_INSPECTION_TOOL_NAMES = [
+  "code_resolve",
+  "code_inspect",
+  "code_orientation",
+  "code_graph",
+  "code_find",
+  "code_health",
+] as const;
+
+const inspectionToolNames = new Set<string>(HEADLESS_INSPECTION_TOOL_NAMES);
+
+/**
+ * Register the managed-child profile: six inspection tools backed by the shared
+ * Workspace provider host, without refactors, settings, UI, or overview state.
+ */
+export default function headlessInspectionProfile(pi: ExtensionAPI): void {
+  const sessions = createSessionCache();
+  const lspState = createLspAdapterState();
+  registerLspSessionLifecycle(pi, lspState, (ctx) => {
+    const session = sessions.getOrCreate(ctx.cwd);
+    session.attachLspController(lspState.controller);
+    session.seedSentinelSnapshot(lspState.sentinelSnapshot);
+    session.setProjectTrusted(ctx.isProjectTrusted());
+  });
+  pi.on("session_shutdown", () => sessions.clear());
+
+  registerCodeIntelligenceTools(
+    pi,
+    sessions.getOrCreate,
+    undefined,
+    CODE_INTELLIGENCE_TOOL_SPECS.filter((spec) => inspectionToolNames.has(spec.name)),
+  );
+}