@dreki-gg/pi-lsp 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @dreki-gg/pi-lsp
 
+## 0.4.1
+
+### Patch Changes
+
+- 6f7034b: Cross-platform fixes for Windows. PR Canvas now opens the browser via the
+  Windows `start` command instead of running `xdg-open` (which does not exist on
+  Windows), so `/pr-canvas start` and `/pr-canvas open` work there. The LSP client
+  derives the workspace folder name with `path.basename` instead of splitting on
+  `/`, fixing the name on Windows-style paths.
+
+## 0.4.0
+
+### Minor Changes
+
+- a5e800f: refactor(lsp): adopt Effect and stop enabling TypeScript by default
+
+  - **Effect-based architecture** — config loading, scaffolding, and the unified `lsp` tool now run as Effect programs against injectable services (`FileSystem`, `CommandResolver`, `ServerManager`). Failures are modeled as `Data.TaggedError` types (`ConfigReadError`, `ConfigWriteError`, `LspValidationError`, `NoCapableServerError`, `NoServerAvailableError`, `LspOperationError`), mirroring the firestore package's conventions. Promise-returning wrappers keep the public API stable.
+  - **TypeScript is no longer a default server** — the scaffolded starter config now ships TypeScript, Python, Rust, and Go as `disabled` examples. No language server is spawned until the user explicitly opts in, so the extension never auto-starts `typescript-language-server` on a fresh setup.
+  - New service-injection tests cover config resolution (global/npx/unavailable command paths) and scaffolding without touching disk or the shell.
+
 ## 0.3.0
 
 ### Minor Changes

package/README.md

@@ -38,6 +38,12 @@ Servers are configured via two config files (project overrides global):
 | `~/.pi/agent/extensions/lsp/config.json` | Global defaults |
 | `.pi/lsp.json` | Project-local overrides |
 
+On first run a starter `config.json` is scaffolded with example servers
+(TypeScript, Python, Rust, Go) — **all `disabled` by default**. No language
+server is enabled out of the box; flip `"disabled": false` (or remove the flag)
+on the ones you want. This keeps the extension from spawning a server you never
+asked for.
+
 ### Example: TypeScript + oxlint
 
 `.pi/lsp.json`:

package/extensions/lsp/client.ts

@@ -6,7 +6,7 @@
  */
 
 import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { basename, resolve } from 'node:path';
 
 import { LspConnection } from './protocol';
 import type {
@@ -246,7 +246,7 @@ export class LspClient {
           symbol: {},
         },
       },
-      workspaceFolders: [{ uri: rootUri, name: this.rootPath.split('/').pop() || 'workspace' }],
+      workspaceFolders: [{ uri: rootUri, name: basename(this.rootPath) || 'workspace' }],
       initializationOptions: this.config.initializationOptions,
     })) as { capabilities?: Record<string, unknown> } | null;
 

package/extensions/lsp/config.ts

@@ -1,21 +1,29 @@
 /**
  * LSP server configuration loader.
  *
- * Purely config-driven — no built-in servers. Users define all servers
- * in their config files:
+ * Purely config-driven — no built-in servers and no language enabled by
+ * default. Users define every server in their config files:
  *
  *   ~/.pi/agent/extensions/lsp/config.json  (global defaults)
  *   .pi/lsp.json                            (project overrides)
  *
  * Project config merges on top of global. `disabled: true` disables a server.
  * `lsp: false` disables all LSP functionality.
+ *
+ * IO and command resolution are expressed as Effect programs against the
+ * FileSystem / CommandResolver services. The `*Effect` functions are the real
+ * implementations; the Promise-returning wrappers provide the live services and
+ * exist for the imperative call sites (extension entry, commands, tests).
  */
 
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { execSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
+import { Effect } from 'effect';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
 
+import { CommandResolver } from './effects/command';
+import { FileSystem } from './effects/filesystem';
+import { makeRuntimeLayer } from './effects/runtime';
+import type { ConfigWriteError } from './errors';
 import type { LspConfigFile, LspServerUserConfig, ResolvedServerConfig } from './types';
 
 // ── Paths ───────────────────────────────────────────────────────────────────
@@ -29,148 +37,162 @@ function projectConfigPath(cwd: string): string {
   return join(cwd, '.pi', 'lsp.json');
 }
 
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
+/**
+ * Starter template scaffolded on first run. Every server is `disabled` so the
+ * extension never auto-starts a language server the user did not opt into —
+ * TypeScript is just one example among several, not a default.
+ */
 const STARTER_CONFIG = `{
   "lsp": {
     "typescript": {
       "command": ["typescript-language-server", "--stdio"],
-      "extensions": [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]
+      "extensions": [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+      "disabled": true
+    },
+    "pyright": {
+      "command": ["pyright-langserver", "--stdio"],
+      "extensions": [".py"],
+      "disabled": true
+    },
+    "rust": {
+      "command": ["rust-analyzer"],
+      "extensions": [".rs"],
+      "disabled": true
+    },
+    "gopls": {
+      "command": ["gopls"],
+      "extensions": [".go"],
+      "disabled": true
     }
   }
 }
 `;
 
+// ── Effect programs ───────────────────────────────────────────────────────────
+
 /**
  * Scaffold a starter global config if neither global nor project config exists.
- * Returns true if a file was created.
+ * Succeeds with `true` when a file was created, `false` otherwise.
  */
-export async function scaffoldGlobalConfig(cwd: string): Promise<boolean> {
-  const globalPath = globalConfigPath();
-  const projectPath = projectConfigPath(cwd);
-
-  if (await fileExists(globalPath)) return false;
-  if (await fileExists(projectPath)) return false;
-
-  await mkdir(dirname(globalPath), { recursive: true });
-  await writeFile(globalPath, STARTER_CONFIG, 'utf8');
-  return true;
-}
+export function scaffoldGlobalConfigEffect(
+  cwd: string,
+): Effect.Effect<boolean, ConfigWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const globalPath = globalConfigPath();
 
-// ── Loading ─────────────────────────────────────────────────────────────────
+    if (yield* fs.fileExists(globalPath)) return false;
+    if (yield* fs.fileExists(projectConfigPath(cwd))) return false;
 
-async function loadJsonFile<T>(path: string): Promise<T | null> {
-  try {
-    const text = await readFile(path, 'utf8');
-    return JSON.parse(text) as T;
-  } catch {
-    return null;
-  }
+    yield* fs.writeTextFile(globalPath, STARTER_CONFIG);
+    return true;
+  });
 }
 
-function commandAvailableVia(command: string, cwd: string): 'global' | 'npx' | null {
-  try {
-    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
-    execSync(`${whichCmd} ${command}`, { stdio: 'pipe', timeout: 5_000 });
-    return 'global';
-  } catch {
-    // not global
-  }
-  try {
-    execSync(`npx --yes ${command} --version`, { stdio: 'pipe', cwd, timeout: 15_000 });
-    return 'npx';
-  } catch {
-    return null;
-  }
+function readJsonFileEffect<T>(path: string): Effect.Effect<T | null, never, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const raw = yield* fs.readTextFile(path).pipe(Effect.either);
+    if (raw._tag === 'Left') return null;
+    try {
+      return JSON.parse(raw.right) as T;
+    } catch {
+      return null;
+    }
+  });
 }
 
-// ── Resolving ───────────────────────────────────────────────────────────────
-
-function resolveServer(
+function resolveServerEffect(
   name: string,
   config: LspServerUserConfig,
   cwd: string,
-): ResolvedServerConfig | null {
-  if (config.disabled) return null;
-  if (!config.command || config.command.length === 0) return null;
-  if (!config.extensions || config.extensions.length === 0) return null;
-
-  let finalCommand = config.command[0];
-  let finalArgs = config.command.slice(1);
-
-  const via = commandAvailableVia(finalCommand, cwd);
-  if (!via) return null;
-  if (via === 'npx') {
-    finalArgs = ['--yes', finalCommand, ...finalArgs];
-    finalCommand = 'npx';
-  }
+): Effect.Effect<ResolvedServerConfig | null, never, CommandResolver> {
+  return Effect.gen(function* () {
+    if (config.disabled) return null;
+    if (!config.command || config.command.length === 0) return null;
+    if (!config.extensions || config.extensions.length === 0) return null;
+
+    let finalCommand = config.command[0];
+    let finalArgs = config.command.slice(1);
+
+    const resolver = yield* CommandResolver;
+    const via = yield* resolver.resolve(finalCommand, cwd);
+    if (!via) return null;
+    if (via === 'npx') {
+      finalArgs = ['--yes', finalCommand, ...finalArgs];
+      finalCommand = 'npx';
+    }
 
-  return {
-    name,
-    command: finalCommand,
-    args: finalArgs,
-    extensions: config.extensions,
-    env: config.env ?? {},
-    initializationOptions: config.initialization ?? {},
-  };
+    return {
+      name,
+      command: finalCommand,
+      args: finalArgs,
+      extensions: config.extensions,
+      env: config.env ?? {},
+      initializationOptions: config.initialization ?? {},
+    } satisfies ResolvedServerConfig;
+  });
 }
 
-// ── Public API ──────────────────────────────────────────────────────────────
-
 export interface LoadedConfig {
   servers: ResolvedServerConfig[];
   globalDisabled: boolean;
   errors: string[];
 }
 
-export async function loadConfig(cwd: string): Promise<LoadedConfig> {
-  const errors: string[] = [];
+export function loadConfigEffect(
+  cwd: string,
+): Effect.Effect<LoadedConfig, never, FileSystem | CommandResolver> {
+  return Effect.gen(function* () {
+    const errors: string[] = [];
 
-  const globalConfig = await loadJsonFile<LspConfigFile>(globalConfigPath());
-  const projectConfig = await loadJsonFile<LspConfigFile>(projectConfigPath(cwd));
+    const globalConfig = yield* readJsonFileEffect<LspConfigFile>(globalConfigPath());
+    const projectConfig = yield* readJsonFileEffect<LspConfigFile>(projectConfigPath(cwd));
 
-  // Check if globally disabled
-  if (globalConfig?.lsp === false || projectConfig?.lsp === false) {
-    return { servers: [], globalDisabled: true, errors };
-  }
-
-  const globalServers = (typeof globalConfig?.lsp === 'object' ? globalConfig.lsp : {}) as Record<
-    string,
-    LspServerUserConfig
-  >;
-  const projectServers = (
-    typeof projectConfig?.lsp === 'object' ? projectConfig.lsp : {}
-  ) as Record<string, LspServerUserConfig>;
-
-  // Merge: project overrides global
-  const allNames = new Set([...Object.keys(globalServers), ...Object.keys(projectServers)]);
-  const servers: ResolvedServerConfig[] = [];
-
-  for (const name of allNames) {
-    const userConfig: LspServerUserConfig = {
-      ...globalServers[name],
-      ...projectServers[name],
-    };
-
-    // Merge env maps properly
-    if (globalServers[name]?.env || projectServers[name]?.env) {
-      userConfig.env = { ...globalServers[name]?.env, ...projectServers[name]?.env };
+    if (globalConfig?.lsp === false || projectConfig?.lsp === false) {
+      return { servers: [], globalDisabled: true, errors };
     }
 
-    const resolved = resolveServer(name, userConfig, cwd);
-    if (resolved) {
-      servers.push(resolved);
+    const globalServers = (typeof globalConfig?.lsp === 'object' ? globalConfig.lsp : {}) as Record<
+      string,
+      LspServerUserConfig
+    >;
+    const projectServers = (
+      typeof projectConfig?.lsp === 'object' ? projectConfig.lsp : {}
+    ) as Record<string, LspServerUserConfig>;
+
+    const allNames = new Set([...Object.keys(globalServers), ...Object.keys(projectServers)]);
+    const servers: ResolvedServerConfig[] = [];
+
+    for (const name of allNames) {
+      const userConfig: LspServerUserConfig = {
+        ...globalServers[name],
+        ...projectServers[name],
+      };
+
+      // Merge env maps properly (project on top of global).
+      if (globalServers[name]?.env || projectServers[name]?.env) {
+        userConfig.env = { ...globalServers[name]?.env, ...projectServers[name]?.env };
+      }
+
+      const resolved = yield* resolveServerEffect(name, userConfig, cwd);
+      if (resolved) servers.push(resolved);
     }
-  }
 
-  return { servers, globalDisabled: false, errors };
+    return { servers, globalDisabled: false, errors };
+  });
+}
+
+// ── Promise wrappers (live services provided) ────────────────────────────────
+
+export function scaffoldGlobalConfig(cwd: string): Promise<boolean> {
+  return Effect.runPromise(
+    scaffoldGlobalConfigEffect(cwd).pipe(Effect.provide(makeRuntimeLayer())),
+  );
+}
+
+export function loadConfig(cwd: string): Promise<LoadedConfig> {
+  return Effect.runPromise(loadConfigEffect(cwd).pipe(Effect.provide(makeRuntimeLayer())));
 }
 
 /** Find all servers that handle a given file extension. */

package/extensions/lsp/effects/command.ts

@@ -0,0 +1,42 @@
+/**
+ * CommandResolver service — decides how a configured LSP server command can be
+ * launched: directly from PATH (`global`), via `npx` as a fallback, or not at
+ * all (`null`).
+ *
+ * Isolated behind an Effect service so config resolution stays pure and tests
+ * can inject deterministic availability without shelling out.
+ */
+
+import { Context, Effect } from 'effect';
+import { execSync } from 'node:child_process';
+
+export type CommandAvailability = 'global' | 'npx' | null;
+
+export interface CommandResolverService {
+  readonly resolve: (command: string, cwd: string) => Effect.Effect<CommandAvailability>;
+}
+
+export class CommandResolver extends Context.Tag('Lsp/CommandResolver')<
+  CommandResolver,
+  CommandResolverService
+>() {}
+
+function commandAvailableVia(command: string, cwd: string): CommandAvailability {
+  try {
+    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+    execSync(`${whichCmd} ${command}`, { stdio: 'pipe', timeout: 5_000 });
+    return 'global';
+  } catch {
+    // not on PATH
+  }
+  try {
+    execSync(`npx --yes ${command} --version`, { stdio: 'pipe', cwd, timeout: 15_000 });
+    return 'npx';
+  } catch {
+    return null;
+  }
+}
+
+export const nodeCommandResolverService: CommandResolverService = {
+  resolve: (command, cwd) => Effect.sync(() => commandAvailableVia(command, cwd)),
+};

package/extensions/lsp/effects/filesystem.ts

@@ -0,0 +1,50 @@
+/**
+ * FileSystem service — the only place the LSP extension touches disk.
+ *
+ * Wrapping Node's `fs/promises` behind an Effect service keeps config loading
+ * pure and injectable: tests can swap in an in-memory implementation, and
+ * failures surface as typed `ConfigReadError` / `ConfigWriteError` values.
+ */
+
+import { Context, Effect } from 'effect';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+import { ConfigReadError, ConfigWriteError } from '../errors';
+
+export interface FileSystemService {
+  /** Read a UTF-8 file, failing with ConfigReadError when unreadable/missing. */
+  readonly readTextFile: (path: string) => Effect.Effect<string, ConfigReadError>;
+  /** Whether a path exists. Never fails. */
+  readonly fileExists: (path: string) => Effect.Effect<boolean>;
+  /** Write a UTF-8 file, creating parent directories first. */
+  readonly writeTextFile: (path: string, content: string) => Effect.Effect<void, ConfigWriteError>;
+}
+
+export class FileSystem extends Context.Tag('Lsp/FileSystem')<FileSystem, FileSystemService>() {}
+
+export const nodeFileSystemService: FileSystemService = {
+  readTextFile: (path) =>
+    Effect.tryPromise({
+      try: () => readFile(path, 'utf8'),
+      catch: (cause) => new ConfigReadError({ path, cause }),
+    }),
+
+  fileExists: (path) =>
+    Effect.tryPromise({
+      try: () => access(path),
+      catch: (cause) => cause,
+    }).pipe(
+      Effect.as(true),
+      Effect.catchAll(() => Effect.succeed(false)),
+    ),
+
+  writeTextFile: (path, content) =>
+    Effect.tryPromise({
+      try: async () => {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, 'utf8');
+      },
+      catch: (cause) => new ConfigWriteError({ path, cause }),
+    }),
+};

package/extensions/lsp/effects/runtime.ts

@@ -0,0 +1,21 @@
+/**
+ * Live Effect layer for the LSP extension.
+ *
+ * Merges the disk-facing FileSystem service and the command-availability
+ * CommandResolver service. Build it once per extension activation and reuse it
+ * for every config/scaffold program.
+ */
+
+import { Layer } from 'effect';
+
+import { CommandResolver, nodeCommandResolverService } from './command';
+import { FileSystem, nodeFileSystemService } from './filesystem';
+
+export function makeRuntimeLayer() {
+  return Layer.mergeAll(
+    Layer.succeed(FileSystem, nodeFileSystemService),
+    Layer.succeed(CommandResolver, nodeCommandResolverService),
+  );
+}
+
+export type LspServices = FileSystem | CommandResolver;

package/extensions/lsp/errors.ts

@@ -0,0 +1,113 @@
+/**
+ * Tagged error types for the LSP extension.
+ *
+ * Modeled with Effect's `Data.TaggedError` so failures are typed, pattern
+ * matchable, and carry structured context. Helpers at the bottom convert these
+ * into human-readable messages, tool `details`, and native `Error`s when an
+ * Effect needs to cross back into Promise-land.
+ */
+
+import { Data } from 'effect';
+
+export class ConfigReadError extends Data.TaggedError('ConfigReadError')<{
+  readonly path: string;
+  readonly cause: unknown;
+}> {
+  get message(): string {
+    return `Failed to read ${this.path}: ${causeMessage(this.cause)}`;
+  }
+}
+
+export class ConfigWriteError extends Data.TaggedError('ConfigWriteError')<{
+  readonly path: string;
+  readonly cause: unknown;
+}> {
+  get message(): string {
+    return `Failed to write ${this.path}: ${causeMessage(this.cause)}`;
+  }
+}
+
+export class LspValidationError extends Data.TaggedError('LspValidationError')<{
+  readonly reason: string;
+}> {
+  get message(): string {
+    return this.reason;
+  }
+}
+
+export class NoCapableServerError extends Data.TaggedError('NoCapableServerError')<{
+  readonly operation: string;
+  readonly filePath: string;
+}> {
+  get message(): string {
+    return `No LSP server with '${this.operation}' capability found for ${this.filePath}. Check /lsp status.`;
+  }
+}
+
+export class NoServerAvailableError extends Data.TaggedError('NoServerAvailableError')<{
+  readonly operation: string;
+}> {
+  get message(): string {
+    return `No LSP server available for ${this.operation}.`;
+  }
+}
+
+export class LspOperationError extends Data.TaggedError('LspOperationError')<{
+  readonly operation: string;
+  readonly server?: string;
+  readonly cause: unknown;
+}> {
+  get message(): string {
+    const server = this.server ? ` (${this.server})` : '';
+    return `LSP ${this.operation}${server} failed: ${causeMessage(this.cause)}`;
+  }
+}
+
+export type LspExtensionError =
+  | ConfigReadError
+  | ConfigWriteError
+  | LspValidationError
+  | NoCapableServerError
+  | NoServerAvailableError
+  | LspOperationError;
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+export function causeMessage(cause: unknown): string {
+  if (cause instanceof Error) return cause.message;
+  return String(cause);
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === 'object' && error !== null && 'message' in error) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === 'string') return message;
+  }
+  return String(error);
+}
+
+export function errorDetails(error: unknown): Record<string, unknown> {
+  if (typeof error === 'object' && error !== null && '_tag' in error) {
+    const tagged = error as { _tag: string } & Record<string, unknown>;
+    const details: Record<string, unknown> = { error: tagged._tag };
+    for (const [key, value] of Object.entries(tagged)) {
+      if (key === '_tag' || key === 'cause') continue;
+      details[key] = value;
+    }
+    details.message = errorMessage(error);
+    return details;
+  }
+
+  return { error: 'lsp_error', message: errorMessage(error) };
+}
+
+/** Convert a tagged/unknown error into a native Error for Promise rejection. */
+export function toNativeError(error: unknown): Error {
+  if (error instanceof Error) return error;
+  const native = new Error(errorMessage(error));
+  if (typeof error === 'object' && error !== null && '_tag' in error) {
+    native.name = String((error as { _tag: unknown })._tag);
+  }
+  return native;
+}

package/extensions/lsp/index.ts

@@ -10,16 +10,29 @@
  */
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Effect } from 'effect';
 
 import { LspClient } from './client';
-import { loadConfig, scaffoldGlobalConfig, serversForExtension, type LoadedConfig } from './config';
-import { registerLspTool, type ServerManager } from './tools';
+import {
+  loadConfigEffect,
+  scaffoldGlobalConfigEffect,
+  serversForExtension,
+  type LoadedConfig,
+} from './config';
+import { makeRuntimeLayer, type LspServices } from './effects/runtime';
+import { errorMessage } from './errors';
+import { registerLspTool, type ServerManagerService } from './tools';
 import type { ResolvedServerConfig } from './types';
 
 export default function lspExtension(pi: ExtensionAPI) {
   let rootPath = '';
   let config: LoadedConfig | null = null;
   const clients = new Map<string, LspClient>();
+  const runtimeLayer = makeRuntimeLayer();
+
+  function runLsp<A, E>(program: Effect.Effect<A, E, LspServices>): Promise<A> {
+    return Effect.runPromise(program.pipe(Effect.provide(runtimeLayer)));
+  }
 
   // ── Client management ───────────────────────────────────────────────
 
@@ -68,7 +81,7 @@ export default function lspExtension(pi: ExtensionAPI) {
 
   // ── Server manager (passed to tool) ───────────────────────────────────
 
-  const serverManager: ServerManager = {
+  const serverManager: ServerManagerService = {
     clientsForFile(filePath: string): LspClient[] {
       if (!config) return [];
       const matching = serversForExtension(config.servers, filePath);
@@ -111,15 +124,18 @@ export default function lspExtension(pi: ExtensionAPI) {
   pi.on('session_start', async (_event, ctx) => {
     rootPath = ctx.cwd;
 
-    const scaffolded = await scaffoldGlobalConfig(rootPath);
+    const scaffolded = await runLsp(scaffoldGlobalConfigEffect(rootPath)).catch((err) => {
+      ctx.ui.notify(`LSP: could not scaffold config: ${errorMessage(err)}`, 'warning');
+      return false;
+    });
     if (scaffolded) {
       ctx.ui.notify(
-        'LSP: created starter config at ~/.pi/agent/extensions/lsp/config.json — edit it to add your servers.',
+        'LSP: created starter config at ~/.pi/agent/extensions/lsp/config.json — every server is disabled, enable the ones you need.',
         'info',
       );
     }
 
-    config = await loadConfig(rootPath);
+    config = await runLsp(loadConfigEffect(rootPath));
     refreshStatus(ctx.ui, config);
   });
 
@@ -139,7 +155,7 @@ export default function lspExtension(pi: ExtensionAPI) {
     description: 'Show LSP server status',
     handler: async (_args, ctx) => {
       rootPath = ctx.cwd;
-      const cfg = await loadConfig(ctx.cwd);
+      const cfg = await runLsp(loadConfigEffect(ctx.cwd));
       config = cfg;
       refreshStatus(ctx.ui, cfg);
       const lines: string[] = ['LSP Status:'];
@@ -173,7 +189,7 @@ export default function lspExtension(pi: ExtensionAPI) {
       await shutdownAll();
       config = null;
       rootPath = ctx.cwd;
-      config = await loadConfig(ctx.cwd);
+      config = await runLsp(loadConfigEffect(ctx.cwd));
       refreshStatus(ctx.ui, config);
       ctx.ui.notify('LSP servers stopped. Will reinitialize on next tool use.', 'info');
     },