@savvy-web/mcp 2.7.5 → 3.0.1

package/index.js

@@ -1,5 +1,8 @@
+import { BiomeFailed, BiomeUnavailable, EngineError, InvalidArgument, McpToolError, Remediation, WorkspaceNotFound, composeRemediatedMessage, truncateEchoed } from "./errors.js";
+import { SilkMarkdown } from "./markdown.js";
 import { makeSilkRuntimeLayer } from "./runtime.js";
+import { SilkToolkit, ToolsLayer } from "./toolkit.js";
 import { CURRENT_MCP_VERSION } from "./version.js";
-import { startMcpServer } from "./server.js";
+import { ServerLayer } from "./server.js";
 
-export { CURRENT_MCP_VERSION, makeSilkRuntimeLayer, startMcpServer };
+export { BiomeFailed, BiomeUnavailable, CURRENT_MCP_VERSION, EngineError, InvalidArgument, McpToolError, Remediation, ServerLayer, SilkMarkdown, SilkToolkit, ToolsLayer, WorkspaceNotFound, composeRemediatedMessage, makeSilkRuntimeLayer, truncateEchoed };

package/internal/project-root.js

@@ -0,0 +1,25 @@
+//#region src/internal/project-root.ts
+/**
+* Pure resolution of the MCP server's project working directory.
+*
+* @packageDocumentation
+*/
+/**
+* Resolves the project directory the MCP server should root its runtime in.
+*
+* @remarks
+* Precedence: a non-empty, non-placeholder `argv[0]`, then
+* `env.SAVVY_MCP_PROJECT_DIR`, then `env.CLAUDE_PROJECT_DIR`, then `cwd()`. A
+* `${...}`-shaped `argv[0]` is an unresolved template placeholder (an MCP
+* client that failed to substitute a config variable) and is ignored, as is
+* a whitespace-only value. Takes `argv`/`env`/`cwd` as parameters rather than
+* reading `process` directly so it stays pure and unit-testable; `main.ts` is
+* the sole caller and supplies the real process bindings.
+*/
+function resolveProjectDir(argv, env, cwd) {
+	const trimmed = argv[0]?.trim();
+	return (trimmed !== void 0 && trimmed.length > 0 && !(trimmed.startsWith("${") && trimmed.endsWith("}")) ? trimmed : void 0) ?? env.SAVVY_MCP_PROJECT_DIR ?? env.CLAUDE_PROJECT_DIR ?? cwd();
+}
+
+//#endregion
+export { resolveProjectDir };

package/main.d.ts

@@ -0,0 +1,25 @@
+//#region src/main.d.ts
+/**
+ * Owns the `savvy-mcp` process: crash guards, project-root resolution, and the
+ * server layer launched over stdio.
+ *
+ * @remarks
+ * No static imports of the server graph — every module reachable from the
+ * MCP tool surface is imported dynamically, after the crash guards are
+ * registered, so an error during that import (or anything downstream) is
+ * caught by `uncaughtException`/`unhandledRejection` rather than crashing
+ * before a handler exists.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Run the savvy MCP server over stdio. Owns the process.
+ *
+ * @remarks
+ * NO static imports of the server graph — see the module remarks.
+ *
+ * @public
+ */
+export declare const main: () => Promise<void>;
+//#endregion
+//# sourceMappingURL=main.d.ts.map

package/main.js

@@ -0,0 +1,42 @@
+//#region src/main.ts
+/**
+* Owns the `savvy-mcp` process: crash guards, project-root resolution, and the
+* server layer launched over stdio.
+*
+* @remarks
+* No static imports of the server graph — every module reachable from the
+* MCP tool surface is imported dynamically, after the crash guards are
+* registered, so an error during that import (or anything downstream) is
+* caught by `uncaughtException`/`unhandledRejection` rather than crashing
+* before a handler exists.
+*
+* @packageDocumentation
+*/
+/* v8 ignore start -- process bootstrap; covered by the server-lifecycle e2e and the silk bins e2e */
+const fatal = (label, error) => {
+	process.stderr.write(`savvy-mcp: ${label}: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+	process.exit(1);
+};
+/**
+* Run the savvy MCP server over stdio. Owns the process.
+*
+* @remarks
+* NO static imports of the server graph — see the module remarks.
+*
+* @public
+*/
+const main = async () => {
+	process.on("uncaughtException", (e) => fatal("uncaught exception", e));
+	process.on("unhandledRejection", (r) => fatal("unhandled rejection", r));
+	const { NodeRuntime, NodeServices } = await import("@effect/platform-node");
+	const { Cause, Exit, Layer, Logger, Runtime } = await import("effect");
+	const { resolveProjectDir } = await import("./internal/project-root.js");
+	const { ServerLayer } = await import("./server.js");
+	const cwd = resolveProjectDir(process.argv.slice(2), process.env, () => process.cwd());
+	const program = Layer.launch(ServerLayer(cwd).pipe(Layer.provide(NodeServices.layer), Layer.provide(Logger.layer([Logger.consolePretty()])), Layer.provide(Layer.succeed(Logger.LogToStderr, true))));
+	NodeRuntime.runMain(program, { teardown: (exit, onExit) => Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) ? onExit(0) : Runtime.defaultTeardown(exit, onExit) });
+};
+/* v8 ignore stop */
+
+//#endregion
+export { main };

package/markdown.js

@@ -0,0 +1,32 @@
+import { Context } from "effect";
+
+//#region src/markdown.ts
+/**
+* The tool annotation that carries each tool's markdown transcript renderer
+* to the server's registration step.
+*
+* @remarks
+* rc.115's `McpServer.registerToolkit` renders every success as
+* `content: [{ type: "text", text: JSON.stringify(encodedResult) }]` plus
+* `structuredContent` and offers no hook over the text
+* (`unstable/ai/McpServer.ts:1577-1585`). `server.ts` therefore registers the
+* toolkit itself through the public `McpServer.addTool` and reads this
+* annotation to put the tool's markdown projection in `content[0].text`
+* while `structuredContent` stays the typed object — the dual channel every
+* tool description promises. A tool without the annotation falls back to the
+* framework's JSON text.
+*
+* @packageDocumentation
+*/
+/**
+* Renders a tool's decoded success value as the markdown transcript an agent
+* reads. Typed over `unknown` because the annotation is read generically at
+* registration; each tool supplies `Schema.decodeUnknownSync(<X>AsMarkdown)`,
+* whose own decoder is the type guard.
+*
+* @public
+*/
+var SilkMarkdown = class extends Context.Service()("@savvy-web/mcp/SilkMarkdown") {};
+
+//#endregion
+export { SilkMarkdown };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "2.7.5",
+	"version": "3.0.1",
 	"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",
@@ -25,6 +25,11 @@
 			"import": "./index.js",
 			"default": "./index.js"
 		},
+		"./main": {
+			"types": "./main.d.ts",
+			"import": "./main.js",
+			"default": "./main.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"bin": {
@@ -33,11 +38,9 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.115",
 		"@effected/commands": "^0.7.0",
-		"@effected/git": "^0.15.0",
-		"@effected/workspaces": "^0.21.0",
-		"@modelcontextprotocol/sdk": "^1.30.0",
-		"@savvy-web/silk-effects": "7.5.3",
-		"effect": "4.0.0-rc.115",
-		"zod": "^4.5.4"
+		"@effected/git": "^0.15.1",
+		"@effected/workspaces": "^0.21.1",
+		"@savvy-web/silk-effects": "8.0.1",
+		"effect": "4.0.0-rc.115"
 	}
 }

package/runtime.js

@@ -1,7 +1,7 @@
+import { Effect, Layer } from "effect";
 import { ToolDiscovery } from "@effected/commands";
 import { Workspaces } from "@effected/workspaces";
 import { ChangesetConfig, ChangesetConfigReader, Changesets, Repos, SilkPublishability, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
-import { Effect, Layer } from "effect";
 
 //#region src/runtime.ts
 /**
@@ -10,7 +10,7 @@ import { Effect, Layer } from "effect";
 * {@link makeSilkRuntimeLayer} builds the full service graph for ONE workspace
 * root: the `@effected/workspaces` kit layers are root-bound at layer build
 * (single-root by design), so the server resolves its project directory once
-* at startup (bin.ts) and builds the layer with that root. The layer still
+* at startup (main.ts) and builds the layer with that root. The layer still
 * requires the platform services (`FileSystem` + `Path` +
 * `ChildProcessSpawner`); the host supplies them via `NodeServices.layer`.
 *
@@ -22,7 +22,7 @@ import { Effect, Layer } from "effect";
 * `Changesets.BranchAnalyzer`, `Changesets.ConfigInspector`,
 * `Changesets.ReleasePlanner`, `Changesets.DepsRegen`, `Repos.ReposManager`,
 * `Repos.ReposConfigStore`, and `Repos.ReposDrift`; requires `ChildProcessSpawner` + `FileSystem`
-* + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
+* + `Path` from the host's platform layer (`NodeServices.layer` in main.ts).
 *
 * @remarks
 * The kit graph (`Workspaces.layerWithGitAndConfigDependenciesSubprocess`)

package/server.js

@@ -1,244 +1,129 @@
-import { effectToZodSchema } from "./schema/effect-to-zod.js";
-import { BiomeCheckAsMarkdown, BiomeCheckResult, runBiomeCheck } from "./tools/biome-check.js";
-import { ChangesetDepsDetectAsMarkdown, ChangesetDepsDetectResult, changesetDepsDetect } from "./tools/changeset-deps-detect.js";
-import { ChangesetDepsRegenAsMarkdown, ChangesetDepsRegenResult, changesetDepsRegen } from "./tools/changeset-deps-regen.js";
-import { ChangesetInspectAsMarkdown, ChangesetInspectResult, changesetInspect } from "./tools/changeset-inspect.js";
-import { ChangesetPreviewAsMarkdown, ChangesetPreviewResult, changesetPreview } from "./tools/changeset-preview.js";
-import { ChangesetValidateAsMarkdown, ChangesetValidateResult, changesetValidate } from "./tools/changeset-validate.js";
-import { ReposInspectAsMarkdown, ReposInspectResult, reposInspect } from "./tools/repos-inspect.js";
-import { ReposManageAsMarkdown, ReposManageResult, reposManage } from "./tools/repos-manage.js";
-import { TurboInspectAsMarkdown, TurboInspectResult, turboInspect } from "./tools/turbo-inspect.js";
-import { WorkspaceInfoAsMarkdown, WorkspaceInfoResult, workspaceInfo } from "./tools/workspace-info.js";
+import { SilkMarkdown } from "./markdown.js";
+import { makeSilkRuntimeLayer } from "./runtime.js";
+import { SilkToolkit, ToolsLayer } from "./toolkit.js";
 import { CURRENT_MCP_VERSION } from "./version.js";
-import { Schema } from "effect";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
+import { Cause, Context, Effect, ErrorReporter, Layer, Option, Result, Schema, Sink, Stream } from "effect";
+import { AiError, McpProtocol, McpSchema, McpServer, Tool } from "effect/unstable/ai";
 
 //#region src/server.ts
+const INTERNAL_TOOL_ERROR_MESSAGE = "Tool execution failed due to an internal server error.";
+const toolErrorResult = (message) => new McpSchema.CallToolResult({
+	isError: true,
+	content: [{
+		type: "text",
+		text: message
+	}]
+});
 /**
-* Constructs the MCP server, registers tools, and connects the stdio
-* transport.
-*
-* @packageDocumentation
+* Hoist a `$ref`-rooted JSON Schema document onto its referenced definition.
+* `Schema.toJsonSchemaDocument` emits `{ $ref: "#/$defs/<id>", $defs }` for
+* any schema annotated with an `identifier` — every result schema here is —
+* and `McpSchema.ToolJsonSchema` needs a `type: "object"` root, so without
+* this no tool would serve an `outputSchema` (rc.115's own `registerToolkit`
+* has the same blind spot). The definitions stay attached for nested refs.
 */
+const hoistRootRef = (schema) => {
+	const ref = schema.$ref;
+	const defs = schema.$defs;
+	if (typeof ref !== "string" || !ref.startsWith("#/$defs/") || typeof defs !== "object" || defs === null) return schema;
+	const target = defs[ref.slice(8)];
+	if (typeof target !== "object" || target === null) return schema;
+	const { $ref: _ref, ...rest } = schema;
+	return {
+		...rest,
+		...target,
+		$defs: defs
+	};
+};
+/** MCP models `structuredContent` as a JSON object, so a `null` or array encoded result is omitted. */
+const toStructuredContent = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 /**
-* The `repos_inspect` wire-level `mode` enum. Exported so tests can assert
-* the boundary rejects an unknown mode without duplicating the enum's
-* member list.
+* Register a toolkit with the running `McpServer`, rendering each success as
+* the tool's markdown transcript in `content[0].text` and the encoded result
+* in `structuredContent`. A port of rc.115's `McpServer.registerToolkit`
+* (`McpServer.ts:1525-1611`) that differs in the success branch only.
+*
+* @remarks
+* `Effect.context<never>()` captures the registration-time services (the
+* handlers' declared dependencies, discharged by the runtime layer) so each
+* call runs against them; `McpServerClient` is provided per call by the
+* framework and is the one service excluded from that capture.
 */
-const ReposInspectModeSchema = z.enum([
-	"status",
-	"config",
-	"drift",
-	"gitmodules"
-]).describe("status = drift report; config = the full agent brief; drift = five-authority submodule reconciliation; gitmodules = decoded .gitmodules sections.");
-/** Wrap a markdown string + structured object in the dual-channel tool result. */
-const structuredResult = (text, structured) => ({
-	content: [{
-		type: "text",
-		text
-	}],
-	structuredContent: structured
+const registerSilkToolkit = (toolkit) => Effect.gen(function* () {
+	const registry = yield* McpServer.McpServer;
+	const built = yield* toolkit;
+	const services = yield* Effect.context();
+	const reportCause = (cause) => Effect.provideContext(ErrorReporter.report(cause), services);
+	for (const tool of Object.values(built.tools)) {
+		const annotations = tool.annotations;
+		const renderMarkdown = Context.getOrUndefined(annotations, SilkMarkdown);
+		const isDeclaredFailure = Schema.is(tool.failureSchema);
+		const outputJsonSchema = hoistRootRef(Tool.getJsonSchemaFromSchema(tool.successSchema));
+		const outputSchema = outputJsonSchema.type === "object" ? yield* Schema.decodeUnknownEffect(McpSchema.ToolJsonSchema)(outputJsonSchema).pipe(Effect.orDie) : void 0;
+		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJsonSchema)(Tool.getJsonSchema(tool)).pipe(Effect.orDie);
+		const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
+		const description = Tool.getDescription(tool);
+		const mcpTool = new McpSchema.Tool({
+			name: tool.name,
+			...description === void 0 ? {} : { description },
+			inputSchema,
+			...outputSchema === void 0 ? {} : { outputSchema },
+			annotations: {
+				...Context.getOption(annotations, Tool.Title).pipe(Option.map((title) => ({ title })), Option.getOrUndefined),
+				readOnlyHint: Context.get(annotations, Tool.Readonly),
+				destructiveHint: Context.get(annotations, Tool.Destructive),
+				idempotentHint: Context.get(annotations, Tool.Idempotent),
+				openWorldHint: Context.get(annotations, Tool.OpenWorld)
+			},
+			...toolMeta === void 0 ? {} : { _meta: toolMeta }
+		});
+		yield* registry.addTool({
+			tool: mcpTool,
+			annotations,
+			handle: (payload) => built.handle(tool.name, payload ?? {}).pipe(Stream.unwrap, Stream.run(Sink.last()), Effect.flatMap(Effect.fromOption), Effect.map((result) => new McpSchema.CallToolResult({
+				isError: false,
+				structuredContent: toStructuredContent(result.encodedResult),
+				content: [{
+					type: "text",
+					text: renderMarkdown === void 0 ? JSON.stringify(result.encodedResult) : renderMarkdown(result.result)
+				}]
+			})), Effect.provideContext(services), Effect.tapCause(Effect.logError), Effect.catchCause((cause) => {
+				const failure = Cause.findError(cause);
+				if (Result.isFailure(failure)) return Cause.hasDies(cause) ? Effect.as(reportCause(cause), toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE)) : Effect.failCause(failure.failure);
+				const error = failure.success;
+				if (AiError.isAiError(error)) {
+					const reason = error.reason;
+					return reason._tag === "ToolParameterValidationError" ? Effect.fail(new McpSchema.InvalidParams({ message: reason.message })) : Effect.as(reportCause(cause), toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE));
+				}
+				const message = isDeclaredFailure(error) && error instanceof Error ? error.message : INTERNAL_TOOL_ERROR_MESSAGE;
+				return Effect.as(reportCause(cause), toolErrorResult(message));
+			}))
+		});
+	}
 });
-/** Build the MCP server for the given context, registering tools. */
-function buildServer(ctx) {
-	const server = new McpServer({
-		name: "savvy-mcp",
-		version: CURRENT_MCP_VERSION
-	});
-	server.registerTool("workspace_info", {
-		description: "Use when you need the Silk workspace layout: runtime, package manager, and a per-workspace summary (publishability, versioning, tag/release state). Prefer this over running shell commands to inspect the workspace. Returns markdown in content[] and a typed object in structuredContent.",
-		inputSchema: { cwd: z.optional(z.string()).describe("Workspace root to analyze. Defaults to the server's project dir.") },
-		outputSchema: effectToZodSchema(WorkspaceInfoResult)
-	}, async (args) => {
-		const root = args.cwd ?? ctx.cwd;
-		const data = await ctx.runtime.runPromise(workspaceInfo(root));
-		const text = Schema.decodeUnknownSync(WorkspaceInfoAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("turbo_inspect", {
-		description: "Read-only Turborepo inspection. mode=cache diagnoses why a task's cache is hitting/missing (per-package status plus the exact hash contributors: input files, env vars, external-dep hashes, global hash). mode=graph returns the task graph and critical path. mode=affected lists changed packages and their dependents. Never executes tasks (uses --dry).",
-		inputSchema: {
-			mode: z.enum([
-				"cache",
-				"graph",
-				"affected"
-			]).describe("Which inspection to run."),
-			task: z.optional(z.string()).describe("Task name (defaults to build:dev for cache/graph)."),
-			base: z.optional(z.string()).describe("Base git ref for affected mode."),
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(TurboInspectResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(turboInspect(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(TurboInspectAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("changeset_inspect", {
-		description: "Read-only changeset analysis for the changeset-manager workflow. mode=branch diffs the current branch against its base and classifies every changed file by owning package (with packagesAffected and the unmapped paths to ask the user about; an unmapped path may carry a machine-readable unmappedHint reason — e.g. a deleted versionFiles/additionalScopes target or a known template mirror — meaning it is probably already accounted for). mode=config surfaces the resolved .changeset/config.json (release surfaces, versionFiles, ignore list). mode=classify maps arbitrary repo-relative paths to their owning package. Prefer this over shelling out to the savvy CLI.",
-		inputSchema: {
-			mode: z.enum([
-				"branch",
-				"config",
-				"classify"
-			]).describe("Which inspection to run."),
-			base: z.optional(z.string()).describe("Override the base branch (branch mode only)."),
-			paths: z.optional(z.array(z.string())).describe("Paths to classify (classify mode only)."),
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(ChangesetInspectResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(changesetInspect(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ChangesetInspectAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("changeset_validate", {
-		description: "Read-only validation of changeset files against the section-aware rules. Pass dir (default .changeset). Returns typed diagnostics (file, rule, line, column, message) plus ok/errorCount in structuredContent. Prefer this over shelling out to savvy changeset lint.",
-		inputSchema: {
-			dir: z.optional(z.string()).describe("Changeset directory to validate (default .changeset)."),
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(ChangesetValidateResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(changesetValidate(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ChangesetValidateAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("changeset_deps_detect", {
-		description: "Read-only preview of the cumulative dependency diff (merge-base -> working tree) per workspace package. Returns each affected package's resolved dependency-table rows (catalog:/workspace: specifiers resolved per side; devDependencies retained) as the exact rows a pure-dependency changeset would carry, plus a coexisting list of untouched prose-only changesets that reference an in-scope package (informational — no need to re-list .changeset/). Does NOT write or delete any file. Prefer this over shelling out to savvy changeset deps detect.",
-		inputSchema: {
-			base: z.optional(z.string()).describe("Override the base branch used to compute the merge-base."),
-			package: z.optional(z.string()).describe("Restrict output to a single workspace package."),
-			packages: z.optional(z.array(z.string())).describe("Restrict output to these workspace packages (unioned with package)."),
-			exclude: z.optional(z.array(z.string())).describe("Drop these packages from the output entirely."),
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(ChangesetDepsDetectResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(changesetDepsDetect(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ChangesetDepsDetectAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("changeset_preview", {
-		description: "Read-only preview of the next release. Runs the genuine changesets engine over the pending changesets and returns each package's version bump (old -> new) plus the rendered CHANGELOG block (dependency tables included), exactly as it would ship. Does not modify the repo. Prefer this over hand-merging changeset files.",
-		inputSchema: { cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.") },
-		outputSchema: effectToZodSchema(ChangesetPreviewResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(changesetPreview(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ChangesetPreviewAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("changeset_deps_regen", {
-		description: "Regenerate pure-dependency changesets: delete stale single-package Dependencies-only changesets and write fresh single-package, patch-bump changesets from the cumulative dependency diff (catalog:/workspace: resolved; devDependencies dropped). Mixed changesets (Dependencies plus other content) are left untouched, and the result's coexisting list accounts for untouched prose-only changesets that reference an in-scope package (informational — no need to re-list .changeset/). Set dryRun=true to preview the plan without touching the filesystem. NOTE: without dryRun this tool MUTATES .changeset/*.md (git-reversible). Prefer this over shelling out to savvy changeset deps regen.",
-		inputSchema: {
-			base: z.optional(z.string()).describe("Override the base branch used to compute the merge-base."),
-			package: z.optional(z.string()).describe("Restrict regeneration to a single workspace package."),
-			packages: z.optional(z.array(z.string())).describe("Restrict regeneration to these workspace packages (unioned with package)."),
-			exclude: z.optional(z.array(z.string())).describe("Skip these packages entirely: nothing written, existing changesets untouched."),
-			dryRun: z.optional(z.boolean()).describe("Compute the plan without writing or deleting any file."),
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(ChangesetDepsRegenResult),
-		annotations: {
-			destructiveHint: true,
-			idempotentHint: false
-		}
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(changesetDepsRegen(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ChangesetDepsRegenAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("repos_inspect", {
-		title: "Inspect vendored repos",
-		description: "Read-only: drift report or parsed .repos/config.json manifest with orientation and notes. mode=status is the per-repo drift summary from ReposManager (present/dirty/commit); mode=config is the parsed manifest; mode=drift reconciles all four submodule authorities (manifest, .gitmodules, worktree, git submodule status) and reports every disagreement; mode=gitmodules decodes the raw .gitmodules file's submodule sections.",
-		inputSchema: {
-			mode: ReposInspectModeSchema,
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(ReposInspectResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(reposInspect(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ReposInspectAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("repos_manage", {
-		title: "Manage vendored repos",
-		description: "Mutating: sync (initialize/reconcile submodules per the manifest), pin (re-pin a repo to a new ref), add (vendor a new repo), note (add/remove/promote an agent note), remove (unvendor a repo), rename (rename a vendored repo's manifest key and worktree), restore (hard-reset a repo's worktree back to its pinned gitlink commit and re-apply sparse paths — DESTRUCTIVE to uncommitted worktree edits; never run implicitly), or deregister (clear a STALE submodule.<section> registration from the superproject's local git config — the phantom entry repos_inspect drift reports as localRegistrationDivergence with no matching manifest entry; refuses a section outside .repos/ and any section still backing a live manifest entry — canonically named or gitdir-diverged — and touches local config only, so nothing is staged). Pass action plus the fields that action needs: pin needs name+ref; add needs url+ref+purpose (name/sparse/orientation optional — pass orientation back from a preceding remove's removedEntry to make a re-vendor lossless); note needs name+op, plus note (op=add), id (op=remove), or id+into (op=promote); remove needs name; rename needs name (the old name) + newName; restore takes an optional names list — omitted, it restores every dirty repo and reports the clean ones as skipped; given, it restores exactly those repos even if already clean; deregister needs section (the registration name exactly as the drift report states it, e.g. .repos/old-name — no submodule. prefix). A decode failure names the missing field. The pin result's markdown surfaces commitMessage and staleNoteIds — review and commit after pinning. The remove result's markdown surfaces commitMessage, removedNotes and the removed entry's orientation block — promote any durable notes elsewhere, keep the orientation if you intend to re-vendor, then review and commit. The rename result's markdown surfaces commitMessage — review and commit after renaming. The restore result's markdown names exactly what was discarded. The deregister result's markdown lists the config keys the removed section carried — nothing to commit afterwards.",
-		inputSchema: {
-			action: z.enum([
-				"sync",
-				"pin",
-				"add",
-				"note",
-				"remove",
-				"rename",
-				"restore",
-				"deregister"
-			]).describe("Which mutation to perform."),
-			name: z.optional(z.string()).describe("Repo name (pin, note, remove, rename; optional override for add)."),
-			newName: z.optional(z.string()).describe("New repo name (rename)."),
-			ref: z.optional(z.string()).describe("Git ref to pin/vendor to (pin, add)."),
-			url: z.optional(z.string()).describe("Repo URL to vendor (add)."),
-			purpose: z.optional(z.string()).describe("One-line purpose for the manifest (add)."),
-			sparse: z.optional(z.array(z.string())).describe("Sparse-checkout patterns (add)."),
-			orientation: z.optional(z.object({
-				layout: z.optional(z.string()),
-				keyPaths: z.optional(z.record(z.string(), z.string())),
-				startHere: z.optional(z.string())
-			})).describe("Orientation block to write (add). Pass back what a preceding remove reported as removedEntry.orientation — add does NOT restore it on its own, so a re-vendor loses it otherwise."),
-			op: z.optional(z.enum([
-				"add",
-				"remove",
-				"promote"
-			])).describe("Note operation (note)."),
-			note: z.optional(z.string()).describe("Note text (note, op=add)."),
-			id: z.optional(z.string()).describe("Note id (note, op=remove|promote)."),
-			into: z.optional(z.enum(["layout", "startHere"])).describe("Orientation target (note, op=promote)."),
-			names: z.optional(z.array(z.string())).describe("Repo names to restore (restore); omitted restores every dirty repo."),
-			section: z.optional(z.string()).describe("Stale registration name to clear (deregister), exactly as the drift report states it (e.g. .repos/old-name); the submodule. prefix is implied."),
-			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
-		},
-		outputSchema: effectToZodSchema(ReposManageResult),
-		annotations: {
-			destructiveHint: true,
-			idempotentHint: false
-		}
-	}, async (args) => {
-		const data = await ctx.runtime.runPromise(reposManage(args, ctx.cwd));
-		const text = Schema.decodeUnknownSync(ReposManageAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	server.registerTool("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 markdown in content[] and a typed object in structuredContent. NOTE: with write/unsafe this tool MUTATES files (git-reversible).",
-		inputSchema: {
-			paths: z.optional(z.array(z.string())).describe("Paths to check. Defaults to the whole workspace."),
-			mode: z.optional(z.enum(["check", "lint"])).describe("check = lint+format+imports (default); lint = lint only."),
-			write: z.optional(z.boolean()).describe("Apply safe fixes (--write)."),
-			unsafe: z.optional(z.boolean()).describe("Apply unsafe fixes (--write --unsafe); implies write."),
-			strict: z.optional(z.boolean()).describe("Report project warnings as errors (marked with originalSeverity). Default: honor project config."),
-			cwd: z.optional(z.string()).describe("Directory to run from. May be the server's workspace root, a directory inside it, or a git worktree of the SAME repository — a worktree contains the run to that worktree instead of the main checkout. Anything else is rejected.")
-		},
-		outputSchema: effectToZodSchema(BiomeCheckResult)
-	}, async (args) => {
-		const data = await runBiomeCheck(args, ctx.cwd);
-		const text = Schema.decodeUnknownSync(BiomeCheckAsMarkdown)(data);
-		return structuredResult(text, data);
-	});
-	return server;
-}
-/** Build the server and connect it over stdio. */
-async function startMcpServer(ctx) {
-	const server = buildServer(ctx);
-	const transport = new StdioServerTransport();
-	await server.connect(transport);
-}
+/**
+* The toolkit registration as a layer: {@link registerSilkToolkit} over
+* `McpServer.layer` (the same reference `McpServer.layerStdio` merges, so
+* layer memoization lands the registration on the served instance), with the
+* handlers bound to `cwd`.
+*/
+const SilkToolsLayer = (cwd) => Layer.effectDiscard(registerSilkToolkit(SilkToolkit)).pipe(Layer.provide(McpServer.McpServer.layer), Layer.provide(ToolsLayer(cwd)));
+/**
+* The whole server as one layer: the ten-tool toolkit, the silk-effects
+* runtime discharging its dependencies, over `McpServer.layerStdio`.
+*
+* `protocols` lists the newest two adapters, newest first — see gotcha 2 in
+* the module remarks. `Cause.IllegalArgumentError` in `layerStdio`'s error
+* channel is `orDie`d: `protocols` is a static two-element literal, so it is
+* an implementer-time defect, not a runtime condition.
+*
+* @public
+*/
+const ServerLayer = (cwd) => SilkToolsLayer(cwd).pipe(Layer.provide(makeSilkRuntimeLayer(cwd)), Layer.provide(McpServer.layerStdio({
+	name: "savvy-mcp",
+	version: CURRENT_MCP_VERSION,
+	protocols: [McpProtocol.v2025_11_25, McpProtocol.v2025_06_18]
+})), Layer.orDie);
 
 //#endregion
-export { ReposInspectModeSchema, buildServer, startMcpServer };
+export { ServerLayer };

package/toolkit.js

@@ -0,0 +1,44 @@
+import { biomeCheckTool, handleBiomeCheck } from "./tools/biome-check.js";
+import { changesetDepsDetectTool, handleChangesetDepsDetect } from "./tools/changeset-deps-detect.js";
+import { changesetDepsRegenTool, handleChangesetDepsRegen } from "./tools/changeset-deps-regen.js";
+import { changesetInspectTool, handleChangesetInspect } from "./tools/changeset-inspect.js";
+import { changesetPreviewTool, handleChangesetPreview } from "./tools/changeset-preview.js";
+import { changesetValidateTool, handleChangesetValidate } from "./tools/changeset-validate.js";
+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 { Toolkit } from "effect/unstable/ai";
+
+//#region src/toolkit.ts
+/**
+* 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.
+*
+* @public
+*/
+const SilkToolkit = Toolkit.make(workspaceInfoTool, turboInspectTool, changesetInspectTool, changesetValidateTool, changesetDepsDetectTool, changesetPreviewTool, changesetDepsRegenTool, reposInspectTool, reposManageTool, biomeCheckTool);
+/**
+* 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`.
+*
+* @public
+*/
+const ToolsLayer = (cwd) => SilkToolkit.toLayer({
+	workspace_info: (params) => handleWorkspaceInfo(cwd, params),
+	turbo_inspect: (params) => handleTurboInspect(cwd, params),
+	changeset_inspect: (params) => handleChangesetInspect(cwd, params),
+	changeset_validate: (params) => handleChangesetValidate(cwd, params),
+	changeset_deps_detect: (params) => handleChangesetDepsDetect(cwd, params),
+	changeset_preview: (params) => handleChangesetPreview(cwd, params),
+	changeset_deps_regen: (params) => handleChangesetDepsRegen(cwd, params),
+	repos_inspect: (params) => handleReposInspect(cwd, params),
+	repos_manage: (params) => handleReposManage(cwd, params),
+	biome_check: (params) => handleBiomeCheck(cwd, params)
+});
+
+//#endregion
+export { SilkToolkit, ToolsLayer };