@savvy-web/mcp 3.4.17 → 3.4.18

package/index.d.ts

@@ -1,6 +1,8 @@
 import { Distribution } from "@effected/engine";
 import { ToolRefusal } from "@effected/mcp";
 import { FileSystem, Layer, Path, Schema, Stdio } from "effect";
+import { ToolDiscovery } from "@effected/commands";
+import { Git } from "@effected/git";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets, Repos, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
 import { ChildProcessSpawner } from "effect/process";
@@ -71,11 +73,13 @@ export type McpToolError = typeof McpToolError.Type;
  * {@link makeSilkRuntimeLayer} passes both through onto its own output via an
  * `Effect.context` identity layer, so they survive `main.ts`'s
  * `Layer.provide(NodeServices.layer)` instead of being fully discharged by
- * it.
+ * it. `ChildProcessSpawner` is passed through the same way, and `Git` (from the
+ * kit graph) plus the shared `ToolDiscovery` are exposed, because
+ * `biome_check` yields all three directly.
  *
  * @public
  */
-type McpServices = SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner | Changesets.DepsRegen | Repos.ReposManager | Repos.ReposConfigStore | Repos.ReposDrift | FileSystem.FileSystem | Path.Path;
+type McpServices = SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner | Changesets.DepsRegen | Repos.ReposManager | Repos.ReposConfigStore | Repos.ReposDrift | Git | ToolDiscovery | ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path;
 /**
  * Build the MCP runtime layer for a workspace root. Provides
  * `SilkWorkspaceAnalyzer`, `WorkspaceRoot`, `Turbo.TurboInspector`,
@@ -137,8 +141,9 @@ interface ServerOptions {
 export declare const ServerLayer: (cwd: string, options?: ServerOptions) => Layer.Layer<never, never, PlatformServices>;
 /**
  * The `biome_check` tool value. Mutating when `write`/`unsafe` is set, so it is
- * annotated non-read-only and non-idempotent; `dependencies` is empty because
- * the handler shells out directly and yields no service.
+ * annotated non-read-only and non-idempotent. `dependencies` lists what the
+ * handler yields: `Git` (worktree containment), `ToolDiscovery` (the Biome
+ * binary) and core's `ChildProcessSpawner` (`Run.collect`).
  */
 declare const biomeCheckTool: Tool.Tool<"biome_check", {
   readonly parameters: Schema.Struct<{
@@ -170,7 +175,7 @@ declare const biomeCheckTool: Tool.Tool<"biome_check", {
   }>;
   readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof EngineError, typeof BiomeFailed, typeof ToolRefusal]>;
   readonly failureMode: "error";
-}, never>;
+}, ChildProcessSpawner.ChildProcessSpawner | Git | ToolDiscovery>;
 /** The `changeset_deps_detect` tool value. */
 declare const changesetDepsDetectTool: Tool.Tool<"changeset_deps_detect", {
   readonly parameters: Schema.Struct<{
@@ -672,7 +677,9 @@ export declare const SilkToolkit: Toolkit.Toolkit<SilkTools>;
  * The handler layer. `cwd` — the project directory `main.ts` resolved once at
  * startup — is closed over as every handler's fallback when a call omits its
  * own `cwd`; the handlers' declared service dependencies are discharged by
- * `makeSilkRuntimeLayer(cwd)` in `server.ts`.
+ * `makeSilkRuntimeLayer(cwd)` in `server.ts`. Building the layer mints the
+ * server's ONE `Exclusive` write lane, so concurrent `biome_check` write passes
+ * are serialized per server.
  *
  * @public
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "3.4.17",
+	"version": "3.4.18",
 	"private": false,
 	"description": "The savvy MCP server — Silk Suite tooling and library knowledge for coding agents",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/mcp",
@@ -37,13 +37,13 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "^4.0.6",
-		"@effected/commands": "^0.16.0",
-		"@effected/engine": "^0.8.0",
-		"@effected/git": "^0.25.1",
-		"@effected/mcp": "^0.9.0",
+		"@effected/commands": "^0.17.0",
+		"@effected/engine": "^0.9.0",
+		"@effected/git": "^0.26.0",
+		"@effected/mcp": "^0.10.0",
 		"@effected/templates": "^0.14.1",
-		"@effected/workspaces": "^0.39.0",
-		"@savvy-web/silk-effects": "^10.1.0",
+		"@effected/workspaces": "^0.39.1",
+		"@savvy-web/silk-effects": "^10.2.0",
 		"effect": "^4.0.6"
 	}
 }

package/runtime.js

@@ -73,7 +73,7 @@ const makeSilkRuntimeLayer = (cwd) => {
 	*/
 	const repos = Layer.mergeAll(Repos.ReposConfigStore.layer, Repos.ReposManager.layer.pipe(Layer.provide(Repos.ReposConfigStore.layer), Layer.provide(Repos.ReposLockdown.layer)), Repos.ReposDrift.layer.pipe(Layer.provide(Repos.ReposConfigStore.layer)));
 	const platformPassthrough = Layer.effectContext(Effect.context());
-	return Layer.mergeAll(SilkWorkspaceAnalyzer.layer.pipe(Layer.provide(analyzerDeps)), Turbo.TurboInspector.layer.pipe(Layer.provide(toolDiscovery)), inspectorAndAnalyzer, depsRegen, repos, platformPassthrough).pipe(Layer.provideMerge(kitGraph));
+	return Layer.mergeAll(SilkWorkspaceAnalyzer.layer.pipe(Layer.provide(analyzerDeps)), Turbo.TurboInspector.layer.pipe(Layer.provide(toolDiscovery)), toolDiscovery, inspectorAndAnalyzer, depsRegen, repos, platformPassthrough).pipe(Layer.provideMerge(kitGraph));
 };
 
 export { makeSilkRuntimeLayer };

package/toolkit.js

@@ -8,10 +8,19 @@ import { handleReposInspect, reposInspectTool } from "./tools/repos-inspect.js";
 import { handleReposManage, reposManageTool } from "./tools/repos-manage.js";
 import { handleTurboInspect, turboInspectTool } from "./tools/turbo-inspect.js";
 import { handleWorkspaceInfo, workspaceInfoTool } from "./tools/workspace-info.js";
+import { Effect } from "effect";
+import { Exclusive } from "@effected/engine";
 import { Toolkit } from "effect/ai";
 
 // src/toolkit.ts
 /**
+* Where the ten tool values and their handlers meet: {@link SilkToolkit} is
+* the served toolkit a structural test can import with no bin and no platform
+* layer; {@link ToolsLayer} binds every handler to one project directory.
+*
+* @packageDocumentation
+*/
+/**
 * The ten savvy-mcp tools — seven read-only, three mutating (`biome_check`
 * with `write`/`unsafe`, `changeset_deps_regen`, `repos_manage`) — in the
 * order `tools/list` serves them.
@@ -23,11 +32,13 @@ const SilkToolkit = Toolkit.make(workspaceInfoTool, turboInspectTool, changesetI
 * The handler layer. `cwd` — the project directory `main.ts` resolved once at
 * startup — is closed over as every handler's fallback when a call omits its
 * own `cwd`; the handlers' declared service dependencies are discharged by
-* `makeSilkRuntimeLayer(cwd)` in `server.ts`.
+* `makeSilkRuntimeLayer(cwd)` in `server.ts`. Building the layer mints the
+* server's ONE `Exclusive` write lane, so concurrent `biome_check` write passes
+* are serialized per server.
 *
 * @public
 */
-const ToolsLayer = (cwd) => SilkToolkit.toLayer({
+const ToolsLayer = (cwd) => SilkToolkit.toLayer(Effect.map(Exclusive.make, (biomeWriteLane) => ({
 	workspace_info: (params) => handleWorkspaceInfo(cwd, params),
 	turbo_inspect: (params) => handleTurboInspect(cwd, params),
 	changeset_inspect: (params) => handleChangesetInspect(cwd, params),
@@ -37,7 +48,7 @@ const ToolsLayer = (cwd) => SilkToolkit.toLayer({
 	changeset_deps_regen: (params) => handleChangesetDepsRegen(cwd, params),
 	repos_inspect: (params) => handleReposInspect(cwd, params),
 	repos_manage: handleReposManage(cwd),
-	biome_check: (params) => handleBiomeCheck(cwd, params)
-});
+	biome_check: (params) => handleBiomeCheck(cwd, params, biomeWriteLane)
+})));
 
 export { SilkToolkit, ToolsLayer };

package/tools/biome-check.js

@@ -1,11 +1,12 @@
 import { BiomeFailed, McpToolError } from "../errors.js";
 import { ToolFailure, ToolRefusal } from "@effected/mcp";
-import { Effect, Schema } from "effect";
-import { Lint } from "@savvy-web/silk-effects";
-import { Tool } from "effect/ai";
-import { spawnSync } from "node:child_process";
+import { Effect, Option, Schema } from "effect";
+import { Run, Tool, ToolDiscovery } from "@effected/commands";
+import { Tool as Tool$1 } from "effect/ai";
 import { realpathSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
+import { Git, TreeIdentity } from "@effected/git";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 
 // src/tools/biome-check.ts
 /**
@@ -136,8 +137,10 @@ const buildBiomeResult = (params) => {
 	};
 };
 /**
-* Canonicalize a path, falling back to lexical resolution when it does not exist
-* (a non-existent target cannot be a symlink pointing out of tree).
+* Canonicalize a caller-supplied path, falling back to lexical resolution when
+* it does not exist (a non-existent target cannot be a symlink pointing out of
+* tree). Also applied to a sibling worktree's `TreeIdentity.toplevel`, so the
+* containment root is spelled the same way as the realpath'd caller paths.
 */
 const canonicalize = (p) => {
 	try {
@@ -146,52 +149,43 @@ const canonicalize = (p) => {
 		return resolve(p);
 	}
 };
-/** Real git probe. One `rev-parse` yielding both paths already absolute. */
-const gitWorktreeProbe = (dir) => {
-	const res = spawnSync("git", [
-		"-C",
-		dir,
-		"rev-parse",
-		"--path-format=absolute",
-		"--git-common-dir",
-		"--show-toplevel"
-	], {
-		encoding: "utf8",
-		timeout: 1e4
-	});
-	if (res.error || (res.status ?? 1) !== 0) return null;
-	const [commonDir, topLevel] = (res.stdout ?? "").trim().split("\n");
-	if (!commonDir || !topLevel) return null;
-	return {
-		commonDir: canonicalize(commonDir.trim()),
-		topLevel: canonicalize(topLevel.trim())
-	};
-};
+/**
+* The working-tree identity of `dir`, or `Option.none` when it is in no
+* working tree. A git failure (git missing, too old for `--path-format`) also
+* answers `none`: the caller then rejects the cwd, which is what an unknown
+* identity must mean for a mutating tool.
+*/
+const treeIdentity = (git, dir) => git.treeIdentity(dir).pipe(Effect.orElseSucceed(() => Option.none()));
 /**
 * Decide which directory tree this run may touch.
 *
 * @remarks A cwd inside the server's root keeps that root. A cwd OUTSIDE it is
-* accepted only when it belongs to a DIFFERENT worktree of the same repository —
-* a shared git common dir but a different top level — and containment then follows
-* that worktree rather than the server's start directory (systems#482). Binding to the start directory
-* meant a call from a sibling worktree silently mutated the main checkout, which in
-* a parallel multi-agent session is another agent's tree. Returns null to reject.
+* accepted only when it belongs to a DIFFERENT worktree of the same repository
+* (`TreeIdentity.relation` answers `"sibling-worktree"`), and containment then
+* follows that worktree's toplevel rather than the server's start directory
+* (systems#482). Binding to the start directory meant a call from a sibling
+* worktree silently mutated the main checkout, which in a parallel multi-agent
+* session is another agent's tree.
+*
+* `"same-tree"` is rejected: `root` can be a strict subdirectory of its own
+* worktree (dev tooling launches the server from packages/mcp/), and a cwd
+* elsewhere in that same checkout must not widen a --write pass to the whole
+* repo, including the .repos/** vendored trees. `"different-repo"`, or either
+* directory being in no working tree, is rejected too.
 *
 * @param root - the server's workspace root, already canonicalized
 * @param cwd - the requested working directory, already canonicalized
-* @param probe - git identity probe; injectable for tests
-* @returns the directory tree to contain to, or null if the cwd must be rejected
+* @returns the directory tree to contain to, or `Option.none` to reject
 */
-const resolveContainmentRoot = (root, cwd, probe = gitWorktreeProbe) => {
-	if (cwd === root || cwd.startsWith(`${root}${sep}`)) return root;
-	const from = probe(cwd);
-	if (!from) return null;
-	const home = probe(root);
-	if (!home) return null;
-	if (from.commonDir !== home.commonDir) return null;
-	if (from.topLevel === home.topLevel) return null;
-	return from.topLevel;
-};
+const resolveContainmentRoot = Effect.fn("biome_check.resolveContainmentRoot")(function* (root, cwd) {
+	if (cwd === root || cwd.startsWith(`${root}${sep}`)) return Option.some(root);
+	const git = yield* Git;
+	const from = yield* treeIdentity(git, cwd);
+	if (Option.isNone(from)) return Option.none();
+	const home = yield* treeIdentity(git, root);
+	if (Option.isNone(home)) return Option.none();
+	return TreeIdentity.relation(from.value, home.value) === "sibling-worktree" ? Option.some(canonicalize(from.value.toplevel)) : Option.none();
+});
 /** Remediation for a path or cwd that escapes the containment tree. */
 const CONTAINMENT_REMEDIATION = { hint: "Keep cwd and every path inside the server's workspace root, or inside a git worktree of the same repository." };
 /** Remediation when no Biome binary can be located. */
@@ -205,81 +199,100 @@ const biomeFailed = (raw, exitCode) => new BiomeFailed({
 	remediation: BIOME_FAILED_REMEDIATION
 });
 /**
+* The Biome tool, global copy first — the same lookup order as silk-effects'
+* `Lint.Biome.findBiome` (`Command.findTool` resolves
+* `Tool.named(name, { prefer: "global" })`). One module-level value, so every
+* call hits the same `ToolDiscovery` probe-cache entry.
+*/
+const BIOME_TOOL = Tool.named("biome", { prefer: "global" });
+/** Per-stream captured-output ceiling for one Biome run. */
+const MAX_OUTPUT_BYTES = 67108864;
+/**
+* Hard cap so a hung Biome process (password prompt, deadlock, stalled
+* watcher) can't block the MCP server. Expiry fails the run as a
+* `CommandFailedError` of kind `"timeout"`.
+*/
+const BIOME_TIMEOUT = "120 seconds";
+/**
+* Backstop on the write lane, a little above {@link BIOME_TIMEOUT} so the run's
+* own typed timeout fires first; the lane only bounds how long one write may
+* hold the permit, never the wait for it.
+*/
+const WRITE_LANE_TIMEOUT = "125 seconds";
+/**
+* Re-scope a resolved Biome command to the request's `cwd` (a local
+* resolution is scoped to the server's root by its `ExecContext`; paths are
+* relative to `cwd`) and kill it with `SIGKILL` on timeout — core's default
+* `SIGTERM` with no `forceKillAfter` would wait on a child that ignores it.
+*/
+const scoped = (command, cwd) => command._tag === "StandardCommand" ? ChildProcess.make(command.command, command.args, {
+	...command.options,
+	cwd,
+	killSignal: "SIGKILL"
+}) : ChildProcess.setCwd(command, cwd);
+/**
 * Run Biome and return structured diagnostics. When `write`/`unsafe` is set,
 * runs a fix pass first, then a read-only gitlab pass to report what remains.
 *
-* @remarks Resolves the Biome binary via {@link Lint.Biome.findBiome} (global
-* first, then the project's package manager). Throws a typed
-* {@link McpToolError} member — a `ToolRefusal` for a cwd/path outside the
-* containment tree or when no binary is found, {@link BiomeFailed} when Biome
-* exits with status > 1 (Biome itself failed, vs. status 1 = lint issues
-* found) — which {@link handleBiomeCheck} lifts into the Effect error channel
-* unchanged.
+* @remarks Resolves the Biome binary through `ToolDiscovery` (global first,
+* then the project's package manager — {@link BIOME_TOOL}) and runs it with
+* `Run.collect`. Fails with a {@link McpToolError} member: a `ToolRefusal` for
+* a cwd/path outside the containment tree or when no binary resolves,
+* {@link BiomeFailed} when Biome exits with status > 1 (Biome itself failed,
+* vs. status 1 = lint issues found), cannot spawn, times out, or overflows the
+* output cap. The write pass runs on `lane`, one permit per server, so two
+* concurrent write calls never interleave on a tree.
+*
+* @param args - the decoded tool parameters
+* @param fallbackCwd - the server's project directory
+* @param lane - the server's write lane
 */
-const runBiomeCheck = async (args, fallbackCwd) => {
+const runBiomeCheck = Effect.fn("biome_check.run")(function* (args, fallbackCwd, lane) {
 	const mode = args.mode ?? "check";
 	const root = canonicalize(fallbackCwd);
 	const cwd = canonicalize(args.cwd ?? fallbackCwd);
-	const containmentRoot = resolveContainmentRoot(root, cwd);
-	if (containmentRoot === null) throw ToolRefusal.refuse(`cwd escapes the workspace root: ${ToolFailure.truncate(args.cwd ?? fallbackCwd)}.`, CONTAINMENT_REMEDIATION);
+	const contained = yield* resolveContainmentRoot(root, cwd);
+	if (Option.isNone(contained)) return yield* ToolRefusal.refuse(`cwd escapes the workspace root: ${ToolFailure.truncate(args.cwd ?? fallbackCwd)}.`, CONTAINMENT_REMEDIATION);
+	const containmentRoot = contained.value;
 	const within = (abs) => abs === containmentRoot || abs.startsWith(`${containmentRoot}${sep}`);
-	const paths = (args.paths && args.paths.length > 0 ? args.paths : ["."]).map((p) => {
+	const rawPaths = args.paths && args.paths.length > 0 ? args.paths : ["."];
+	const paths = [];
+	for (const p of rawPaths) {
 		const lexical = resolve(cwd, p);
-		if (!within(canonicalize(lexical))) throw ToolRefusal.refuse(`path escapes the workspace root: ${ToolFailure.truncate(p)}.`, CONTAINMENT_REMEDIATION);
-		return relative(cwd, lexical) || ".";
-	});
+		if (!within(canonicalize(lexical))) return yield* ToolRefusal.refuse(`path escapes the workspace root: ${ToolFailure.truncate(p)}.`, CONTAINMENT_REMEDIATION);
+		paths.push(relative(cwd, lexical) || ".");
+	}
 	const doWrite = Boolean(args.write || args.unsafe);
-	const biomeCmd = Lint.Biome.findBiome();
-	if (!biomeCmd) throw ToolRefusal.refuse("Biome not found.", BIOME_REMEDIATION);
-	const parts = biomeCmd.split(" ");
-	const bin = parts[0];
-	const prefix = parts.slice(1);
-	const maxBuffer = 67108864;
-	const timeout = 12e4;
-	const killSignal = "SIGKILL";
+	const biome = yield* (yield* ToolDiscovery).resolve(BIOME_TOOL).pipe(Effect.mapError((error) => error._tag === "ToolNotFoundError" ? ToolRefusal.refuse("Biome not found.", BIOME_REMEDIATION) : ToolRefusal.refuse(`Biome could not be resolved: ${error.message}`, BIOME_REMEDIATION)));
+	/** One Biome pass; exit 0/1 is a result, anything else a {@link BiomeFailed}. */
+	const pass = (label, argv) => Run.collect(scoped(biome.command(...argv), cwd), {
+		timeout: BIOME_TIMEOUT,
+		maxOutputBytes: MAX_OUTPUT_BYTES
+	}).pipe(Effect.mapError((error) => biomeFailed(`${label} could not run: ${error.message}`, error.exitCode)), Effect.flatMap((output) => output.exitCode > 1 ? Effect.fail(biomeFailed(`${label} failed (exit ${output.exitCode}): ${output.stderr.trim() || "unknown error"}`, output.exitCode)) : Effect.succeed(output)));
 	let wrote = false;
 	if (doWrite) {
 		const writeArgs = [
-			...prefix,
 			mode,
 			"--write",
 			...args.unsafe ? ["--unsafe"] : [],
 			"--no-errors-on-unmatched",
 			...paths
 		];
-		const fix = spawnSync(bin, writeArgs, {
-			cwd,
-			encoding: "utf8",
-			maxBuffer,
-			timeout,
-			killSignal
-		});
-		if (fix.error) throw biomeFailed(`Biome --write could not run: ${fix.error.message}`);
-		if ((fix.status ?? 0) > 1) throw biomeFailed(`Biome --write failed (exit ${fix.status}): ${(fix.stderr ?? "").trim() || "unknown error"}`, fix.status ?? void 0);
+		yield* lane.run(pass("Biome --write", writeArgs), { timeout: WRITE_LANE_TIMEOUT }).pipe(Effect.catchTag("ExclusiveTimeout", (timeout) => Effect.fail(biomeFailed(`Biome --write did not finish: ${timeout.message}`))));
 		wrote = true;
 	}
-	const readArgs = [
-		...prefix,
+	const read = yield* pass("Biome", [
 		mode,
 		"--reporter=gitlab",
 		"--no-errors-on-unmatched",
 		...paths
-	];
-	const read = spawnSync(bin, readArgs, {
-		cwd,
-		encoding: "utf8",
-		maxBuffer,
-		timeout,
-		killSignal
-	});
-	if (read.error) throw biomeFailed(`Biome could not run: ${read.error.message}`);
-	if ((read.status ?? 0) > 1) throw biomeFailed(`Biome failed (exit ${read.status}): ${(read.stderr ?? "").trim() || "unknown error"}`, read.status ?? void 0);
+	]);
 	return buildBiomeResult({
-		diagnostics: parseBiomeGitlab(read.stdout ?? ""),
+		diagnostics: parseBiomeGitlab(read.stdout),
 		wrote,
 		...args.strict !== void 0 ? { strict: args.strict } : {}
 	});
-};
+});
 /** Wire parameters for `biome_check`. */
 const BiomeCheckParams = Schema.Struct({
 	paths: Schema.optionalKey(Schema.Array(Schema.String).annotate({ description: "Paths to check. Defaults to the whole workspace." })),
@@ -291,31 +304,30 @@ const BiomeCheckParams = Schema.Struct({
 });
 /**
 * The `biome_check` tool value. Mutating when `write`/`unsafe` is set, so it is
-* annotated non-read-only and non-idempotent; `dependencies` is empty because
-* the handler shells out directly and yields no service.
+* annotated non-read-only and non-idempotent. `dependencies` lists what the
+* handler yields: `Git` (worktree containment), `ToolDiscovery` (the Biome
+* binary) and core's `ChildProcessSpawner` (`Run.collect`).
 */
-const biomeCheckTool = Tool.make("biome_check", {
+const biomeCheckTool = Tool$1.make("biome_check", {
 	description: "Run Biome over a path and get structured diagnostics back. mode=check (default; lint + format + organize-imports) or mode=lint. Set write=true to apply safe fixes (--write), unsafe=true for unsafe fixes (--write --unsafe). Severities match the project's Biome config (what `biome check` reports); set strict=true to surface project warnings as errors, each marked with its originalSeverity. Prefer this over shelling out to biome; the LSP already covers files you've edited. Returns a typed object in structuredContent (content[] carries the same object as JSON). NOTE: with write/unsafe this tool MUTATES files (git-reversible).",
 	parameters: BiomeCheckParams,
 	success: BiomeCheckResult,
-	failure: McpToolError
-}).annotate(Tool.Title, "Biome check").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false).annotate(Tool.OpenWorld, false);
-/**
-* Every declared failure, recognized from the one union the tool declares, so
-* a member added to {@link McpToolError} is passed through here without a
-* second list to keep in step.
-*/
-const isMcpToolError = Schema.is(McpToolError);
+	failure: McpToolError,
+	dependencies: [
+		Git,
+		ToolDiscovery,
+		ChildProcessSpawner.ChildProcessSpawner
+	]
+}).annotate(Tool$1.Title, "Biome check").annotate(Tool$1.Readonly, false).annotate(Tool$1.Destructive, false).annotate(Tool$1.Idempotent, false).annotate(Tool$1.OpenWorld, false);
 /**
-* Wire handler: {@link runBiomeCheck} lifted into Effect. The typed members it
-* throws pass through unchanged; anything else (a defect in the parser, say)
-* is reported as {@link BiomeFailed} so the error channel stays closed over
-* {@link McpToolError} — nothing undeclared reaches core, which would scrub
-* it to a generic internal-error text.
+* Wire handler: {@link runBiomeCheck} with its error channel closed over
+* {@link McpToolError}. A defect (a bug in the parser, say) is reported as
+* {@link BiomeFailed} rather than reaching core, which would scrub it to a
+* generic internal-error text.
+*
+* @param fallbackCwd - the server's project directory
+* @param lane - the server's one write lane, built once in `ToolsLayer`
 */
-const handleBiomeCheck = (fallbackCwd, params) => Effect.tryPromise({
-	try: () => runBiomeCheck(params, fallbackCwd),
-	catch: (cause) => isMcpToolError(cause) ? cause : biomeFailed(`Biome check failed: ${cause instanceof Error ? cause.message : String(cause)}`)
-});
+const handleBiomeCheck = (fallbackCwd, params, lane) => runBiomeCheck(params, fallbackCwd, lane).pipe(Effect.catchDefect((defect) => Effect.fail(biomeFailed(`Biome check failed: ${defect instanceof Error ? defect.message : String(defect)}`))));
 
 export { BiomeCheckParams, BiomeCheckResult, BiomeDiagnostic, BiomeSeverity, biomeCheckTool, buildBiomeResult, handleBiomeCheck, parseBiomeGitlab, resolveContainmentRoot, runBiomeCheck };

package/version.js

@@ -6,6 +6,6 @@
 *
 * @packageDocumentation
 */
-const CURRENT_MCP_VERSION = "3.4.17";
+const CURRENT_MCP_VERSION = "3.4.18";
 
 export { CURRENT_MCP_VERSION };