@savvy-web/mcp 3.2.3 → 3.3.0

package/server.js

@@ -1,11 +1,9 @@
-import { SilkMarkdown } from "./markdown.js";
 import { makeSilkRuntimeLayer } from "./runtime.js";
 import { SilkToolkit, ToolsLayer } from "./toolkit.js";
 import { CURRENT_MCP_VERSION } from "./version.js";
-import { Cause, Context, Effect, ErrorReporter, Layer, Option, Result, Schema, Stream } from "effect";
-import { CurrentLogLevel } from "effect/References";
-import { AiError, McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/unstable/ai";
-import { HttpServerRequest } from "effect/unstable/http";
+import { McpStdio, McpToolkit } from "@effected/mcp";
+import { Layer, Option } from "effect";
+import { distributionSuffix } from "@effected/engine";
 
 //#region src/server.ts
 /**
@@ -25,187 +23,33 @@ const SERVER_INSTRUCTIONS = [
 	"changeset_inspect, changeset_validate, changeset_preview: the branch diff by owning package, typed CSH001-CSH005 diagnostics, and the CHANGELOG the pending changesets would produce.",
 	"changeset_deps_detect (reads) and changeset_deps_regen (deletes and recreates) dependency changesets.",
 	"repos_inspect (reads) and repos_manage (mutates) the vendored reference repos under .repos/; repos_manage restore discards uncommitted worktree edits.",
-	"Every successful result carries a markdown transcript in content[0].text and the typed object in structuredContent; read structuredContent when you need fields. A failure is an isError result whose content[0].text carries the message and remediation, with no structuredContent. Every tool takes an optional cwd; omit it to use the server's project directory."
+	"Every successful result is a typed object in structuredContent (content[0].text carries the same object as JSON). A failure is an isError result whose content[0].text carries the message and remediation, with no structuredContent. Every tool takes an optional cwd; omit it to use the server's project directory."
 ].join("\n");
-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
-	}]
-});
-const toolResultContent = (encoded) => encoded === void 0 ? [] : [{
-	type: "text",
-	text: JSON.stringify(encoded)
-}];
-const omitRequestServices = Context.omit(McpSchema.McpRequestContext, McpSchema.McpServerClient, HttpServerRequest.HttpServerRequest, CurrentLogLevel);
-const isParameterValidationError = (error) => AiError.isAiError(error) && error.reason._tag === "ToolParameterValidationError";
 /**
-* 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 a strict MCP client needs a `type: "object"` root on `outputSchema`,
-* so without this no tool would serve one. The definitions stay attached
-* for nested refs. (rc.116's own `registerToolkit` inlines the top-level
-* reference of the INPUT schema through an internal helper and serves the
-* output document verbatim; this is the public-API equivalent for both.)
+* The toolkit registration as a layer: `McpToolkit.layer` over core's
+* module-level `McpServer.McpServer.layer` — the same reference
+* `McpStdio.layer` serves, so layer memoization lands the registration on the
+* served instance — with the handlers bound to `cwd`.
 */
-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
-	};
-};
-/**
-* The served input schema: MCP requires an object root, so a top-level `$ref`
-* is inlined, and a strict tool is emitted with `onExcessProperty: "error"`
-* so the client sees `additionalProperties: false`. Mirrors rc.116's
-* `toolInputJsonSchema` through public API (`Schema.toJsonSchemaDocument` +
-* {@link hoistRootRef} in place of the internal `resolveTopLevelReference`).
-*/
-const toolInputJsonSchema = (schema, strict) => {
-	const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: strict ? "error" : "ignore" });
-	const withDefs = Object.keys(document.definitions).length === 0 ? document.schema : {
-		...document.schema,
-		$defs: document.definitions
-	};
-	return hoistRootRef(withDefs);
-};
-/** 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;
-/**
-* 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.116's `McpServer.registerToolkit`
-* that differs in the success branch and the `outputSchema` gate only (see
-* the module remarks).
-*
-* @remarks
-* `Effect.context<never>()` captures the registration-time services (the
-* handlers' declared dependencies, discharged by the runtime layer) so each
-* call runs against them; the per-request services (`McpRequestContext`,
-* the legacy `McpServerClient`, the HTTP request, the request log level) are
-* omitted from that capture because the framework provides them per call.
-*
-* @internal exported for the in-process suite, which registers fixture
-* toolkits (a strict tool, for one) through the same path the served
-* toolkit takes.
-*/
-const registerSilkToolkit = (toolkit) => Effect.gen(function* () {
-	const registry = yield* McpServer.McpServer;
-	const built = yield* toolkit.pipe(Effect.updateContext((context) => {
-		const services = new Map(context.mapUnsafe);
-		for (const tool of Object.values(toolkit.tools)) {
-			const handler = services.get(tool.id);
-			if (handler !== void 0) services.set(tool.id, {
-				...handler,
-				context: omitRequestServices(handler.context)
-			});
-		}
-		return Context.makeUnsafe(services);
-	}));
-	const services = omitRequestServices(yield* Effect.context());
-	const reportCause = (cause) => Effect.provideContext(ErrorReporter.report(cause), services);
-	const internalToolError = (cause) => {
-		const failure = Cause.findFail(cause);
-		return Result.isFailure(failure) && !Cause.hasDies(cause) ? Effect.failCause(failure.failure) : Effect.logError(cause).pipe(Effect.andThen(reportCause(cause)), Effect.as(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE)));
-	};
-	const registrations = [];
-	for (const tool of Object.values(built.tools)) {
-		const strict = Tool.getStrictMode(tool) === true;
-		const rawJsonSchema = Tool.isDynamic(tool) ? tool.jsonSchema : void 0;
-		if (strict && rawJsonSchema !== void 0) return yield* Effect.die(`McpServer cannot strictly validate the raw JSON Schema for tool '${tool.name}'; use an Effect Schema instead`);
-		const decodeOptions = strict ? { onExcessProperty: "error" } : void 0;
-		const annotations = tool.annotations;
-		const renderMarkdown = Context.getOrUndefined(annotations, SilkMarkdown);
-		const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
-		const isDeclaredFailure = Schema.is(tool.failureSchema);
-		const encodeFailure = Schema.encodeUnknownEffect(tool.failureSchema);
-		const declaredFailureResult = (error) => error instanceof Error ? Effect.succeed(toolErrorResult(error.message)) : Effect.map(encodeFailure(error), (encoded) => new McpSchema.CallToolResult({
-			isError: true,
-			content: toolResultContent(encoded)
-		}));
-		const handleCause = (cause) => {
-			const failure = Cause.findFail(cause);
-			if (Result.isSuccess(failure)) {
-				const error = failure.success.error;
-				const origin = Context.get(Cause.reasonAnnotations(failure.success), Toolkit.FailureOrigin);
-				if (origin === "parameters" && isParameterValidationError(error)) return Effect.fail(new McpSchema.InvalidParams({ message: error.reason.message }));
-				if (origin === "handler" && isDeclaredFailure(error)) return Effect.logError(cause).pipe(Effect.andThen(Effect.catchCause(declaredFailureResult(error), internalToolError)));
-			}
-			return internalToolError(cause);
-		};
-		const outputJsonSchema = hoistRootRef(Tool.getJsonSchemaFromSchema(tool.successSchema));
-		const outputSchema = outputJsonSchema.type === "object" ? yield* Schema.decodeUnknownEffect(McpSchema.ToolOutputJson)(outputJsonSchema).pipe(Effect.orDie) : void 0;
-		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(rawJsonSchema ?? toolInputJsonSchema(tool.parametersSchema, strict)).pipe(Effect.orDie);
-		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 }
-		});
-		registrations.push({
-			tool: mcpTool,
-			annotations,
-			handle: (payload) => built.handle(tool.name, payload ?? {}, void 0, decodeOptions).pipe(Stream.unwrap, Stream.runLast, Effect.flatMap(Effect.fromOption), Effect.flatMap((result) => result.isFailure && result.failureOrigin !== "handler" ? Effect.failCause(Cause.annotate(Cause.fail(result.result), Context.make(Toolkit.FailureOrigin, result.failureOrigin ?? "result"))) : Effect.succeed(new McpSchema.CallToolResult({
-				isError: result.isFailure,
-				structuredContent: result.isFailure ? void 0 : toStructuredContent(result.encodedResult),
-				content: result.isFailure || renderMarkdown === void 0 ? toolResultContent(result.encodedResult) : [{
-					type: "text",
-					text: renderMarkdown(result.result)
-				}]
-			}))), Effect.catchCause(handleCause), Effect.provideContext(services))
-		});
-	}
-	for (const registration of registrations) yield* registry.addTool(registration);
-});
-/**
-* 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)));
+const SilkToolsLayer = (cwd) => McpToolkit.layer(SilkToolkit, { strict: "annotated" }).pipe(Layer.provide(ToolsLayer(cwd)));
 /**
 * The whole server as one layer: the ten-tool toolkit, the silk-effects
-* runtime discharging its dependencies, over `McpServer.layerStdio`.
+* runtime discharging its dependencies, over `@effected/mcp`'s
+* `McpStdio.layer`.
 *
-* `protocols` lists the stateless `2026-07-28` adapter first, then the two
-* newest stateful ones — see gotcha 2 in the module remarks.
-* `Cause.IllegalArgumentError` in `layerStdio`'s error channel is `orDie`d:
-* `protocols` is a static literal with exactly one stateless member, so a
-* failure there is an implementer-time defect, not a runtime condition.
+* `McpStdio.layer` is `McpServer.layerStdio` with the kit's default
+* `protocols` (the stateless `2026-07-28` adapter first, then the two newest
+* stateful ones — see gotcha 2), `LogToStderr` merged into its output, a
+* stdin guard answering a non-JSON line with `-32700`, and `Layer.orDie`.
 *
 * @public
 */
-const ServerLayer = (cwd) => SilkToolsLayer(cwd).pipe(Layer.provide(makeSilkRuntimeLayer(cwd)), Layer.provide(McpServer.layerStdio({
+const ServerLayer = (cwd, options = {}) => SilkToolsLayer(cwd).pipe(Layer.provide(makeSilkRuntimeLayer(cwd)), Layer.provide(McpStdio.layer({
 	name: "savvy-mcp",
-	version: CURRENT_MCP_VERSION,
+	version: `${CURRENT_MCP_VERSION}${distributionSuffix(Option.fromNullishOr(options.distribution))}`,
 	description: "Structured Silk Suite workspace tools: workspace, turbo, biome, changesets and vendored repos.",
-	instructions: SERVER_INSTRUCTIONS,
-	protocols: [
-		McpProtocol.v2026_07_28,
-		McpProtocol.v2025_11_25,
-		McpProtocol.v2025_06_18
-	]
-})), Layer.orDie);
+	instructions: SERVER_INSTRUCTIONS
+})));
 
 //#endregion
-export { SERVER_INSTRUCTIONS, ServerLayer, registerSilkToolkit };
+export { SERVER_INSTRUCTIONS, ServerLayer };

package/tools/biome-check.js

@@ -1,6 +1,6 @@
-import { BiomeFailed, BiomeUnavailable, InvalidArgument, McpToolError, composeRemediatedMessage, invalidArgument, truncateEchoed } from "../errors.js";
-import { SilkMarkdown } from "../markdown.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { BiomeFailed, BiomeUnavailable, InvalidArgument, McpToolError, invalidArgument } from "../errors.js";
+import { ToolFailure } from "@effected/mcp";
+import { Effect, Schema } from "effect";
 import { Lint } from "@savvy-web/silk-effects";
 import { Tool } from "effect/unstable/ai";
 import { spawnSync } from "node:child_process";
@@ -135,25 +135,6 @@ const buildBiomeResult = (params) => {
 		guidance: diagnostics.length === 0 ? GUIDANCE_ERRORS : guidance
 	};
 };
-/** Render the structured result as markdown. */
-const renderMarkdown = (data) => {
-	if (data.diagnostics.length === 0) return `# biome — clean\n\n✅ No remaining diagnostics.${data.wrote ? " A --write pass ran; check `git diff` for what changed." : ""}`;
-	const upgraded = data.summary.upgradedWarnings ?? 0;
-	const upgradedNote = upgraded > 0 ? ` (${upgraded} strict-upgraded from project warnings)` : "";
-	const lines = [`# biome — ${data.summary.errors} error(s)${upgradedNote}, ${data.summary.warnings} warning(s)`, ``];
-	if (data.wrote) lines.push(`A --write pass ran; the diagnostics below remain unfixed.`, ``);
-	for (const d of data.diagnostics) {
-		const severity = d.originalSeverity ? `${d.severity} (project ${d.originalSeverity}, strict)` : d.severity;
-		lines.push(`- \`${d.file}:${d.line}\` **${severity}** ${d.rule} — ${d.message}`);
-	}
-	lines.push(``, `---`, data.guidance);
-	return lines.join("\n");
-};
-/** One-way transform: result to markdown. Encoding back is forbidden. */
-const BiomeCheckAsMarkdown = BiomeCheckResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform(renderMarkdown),
-	encode: SchemaGetter.forbidden(() => "BiomeCheckAsMarkdown is one-way: markdown cannot be parsed back.")
-}));
 /**
 * 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).
@@ -220,7 +201,7 @@ const BIOME_FAILED_REMEDIATION = { hint: "Biome did not complete; the message ca
 /** Build a {@link BiomeFailed} from a spawn error or a non-lint exit status. */
 const biomeFailed = (raw, exitCode) => new BiomeFailed({
 	...exitCode === void 0 ? {} : { exitCode },
-	message: composeRemediatedMessage(raw, BIOME_FAILED_REMEDIATION),
+	message: ToolFailure.message(raw, BIOME_FAILED_REMEDIATION),
 	remediation: BIOME_FAILED_REMEDIATION
 });
 /**
@@ -240,17 +221,17 @@ const runBiomeCheck = async (args, fallbackCwd) => {
 	const root = canonicalize(fallbackCwd);
 	const cwd = canonicalize(args.cwd ?? fallbackCwd);
 	const containmentRoot = resolveContainmentRoot(root, cwd);
-	if (containmentRoot === null) throw invalidArgument("cwd", `cwd escapes the workspace root: ${truncateEchoed(args.cwd ?? fallbackCwd)}.`, CONTAINMENT_REMEDIATION);
+	if (containmentRoot === null) throw invalidArgument("cwd", `cwd escapes the workspace root: ${ToolFailure.truncate(args.cwd ?? fallbackCwd)}.`, CONTAINMENT_REMEDIATION);
 	const within = (abs) => abs === containmentRoot || abs.startsWith(`${containmentRoot}${sep}`);
 	const paths = (args.paths && args.paths.length > 0 ? args.paths : ["."]).map((p) => {
 		const lexical = resolve(cwd, p);
-		if (!within(canonicalize(lexical))) throw invalidArgument("paths", `path escapes the workspace root: ${truncateEchoed(p)}.`, CONTAINMENT_REMEDIATION);
+		if (!within(canonicalize(lexical))) throw invalidArgument("paths", `path escapes the workspace root: ${ToolFailure.truncate(p)}.`, CONTAINMENT_REMEDIATION);
 		return relative(cwd, lexical) || ".";
 	});
 	const doWrite = Boolean(args.write || args.unsafe);
 	const biomeCmd = Lint.Biome.findBiome();
 	if (!biomeCmd) throw new BiomeUnavailable({
-		message: composeRemediatedMessage("Biome not found.", BIOME_REMEDIATION),
+		message: ToolFailure.message("Biome not found.", BIOME_REMEDIATION),
 		remediation: BIOME_REMEDIATION
 	});
 	const parts = biomeCmd.split(" ");
@@ -317,11 +298,11 @@ const BiomeCheckParams = Schema.Struct({
 * the handler shells out directly and yields no service.
 */
 const biomeCheckTool = Tool.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 markdown in content[] and a typed object in structuredContent. NOTE: with write/unsafe this tool MUTATES files (git-reversible).",
+	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).annotate(SilkMarkdown, Schema.decodeUnknownSync(BiomeCheckAsMarkdown));
+}).annotate(Tool.Title, "Biome check").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false).annotate(Tool.OpenWorld, false);
 const isMcpToolError = (u) => u instanceof InvalidArgument || u instanceof BiomeUnavailable || u instanceof BiomeFailed;
 /**
 * Wire handler: {@link runBiomeCheck} lifted into Effect. The typed members it
@@ -335,4 +316,4 @@ const handleBiomeCheck = (fallbackCwd, params) => Effect.tryPromise({
 });
 
 //#endregion
-export { BiomeCheckAsMarkdown, BiomeCheckParams, BiomeCheckResult, BiomeDiagnostic, BiomeSeverity, biomeCheckTool, buildBiomeResult, handleBiomeCheck, parseBiomeGitlab, resolveContainmentRoot, runBiomeCheck };
+export { BiomeCheckParams, BiomeCheckResult, BiomeDiagnostic, BiomeSeverity, biomeCheckTool, buildBiomeResult, handleBiomeCheck, parseBiomeGitlab, resolveContainmentRoot, runBiomeCheck };

package/tools/changeset-deps-detect.js

@@ -1,6 +1,5 @@
 import { McpToolError, mapEngineError } from "../errors.js";
-import { SilkMarkdown } from "../markdown.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, Schema } from "effect";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Tool } from "effect/unstable/ai";
@@ -32,49 +31,6 @@ const ChangesetDepsDetectResult = Schema.Struct({
 	description: "Read-only per-package dependency diff (devDependencies retained). No files are written."
 });
 /**
-* Render a repo-derived value as an inert markdown code span so a crafted path,
-* package, or dependency name cannot inject markdown structure into the
-* transcript an agent reads. Control characters (which would break table rows
-* and headings) are flattened to spaces, table-cell pipes are escaped, and the
-* span is fenced with a backtick run longer than any in the value — CommonMark
-* forbids backslash-escaping a backtick inside a code span.
-*/
-const mdInline = (value) => {
-	const safe = value.replace(/\p{Cc}/gu, " ").replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
-	const longest = safe.match(/`+/g)?.reduce((m, run) => Math.max(m, run.length), 0) ?? 0;
-	const fence = "`".repeat(longest + 1);
-	const pad = safe.startsWith("`") || safe.endsWith("`") || safe.trim() === "" ? " " : "";
-	return `${fence}${pad}${safe}${pad}${fence}`;
-};
-/** Render the structured result as a markdown transcript. */
-const renderMarkdown = (data) => {
-	const coexistingLines = data.coexisting.length === 0 ? [] : [
-		``,
-		`## Coexisting prose changesets (untouched by regen)`,
-		``,
-		...data.coexisting.map((c) => `- ${mdInline(c.file)} (${c.packages.map(mdInline).join(", ")})`)
-	];
-	if (data.packages.length === 0) return [
-		`# changeset deps detect — ${mdInline(data.root)}`,
-		``,
-		`No dependency changes detected.`
-	].concat(coexistingLines).join("\n").trimEnd();
-	const lines = [`# changeset deps detect — ${mdInline(data.root)}`, ``];
-	for (const pkg of data.packages) {
-		lines.push(`## ${mdInline(pkg.package)} — ${mdInline(pkg.relativePath)}`, ``);
-		lines.push(`| Dependency | Type | Action | From | To |`, `| --- | --- | --- | --- | --- |`);
-		for (const r of pkg.rows) lines.push(`| ${mdInline(r.dependency)} | ${r.type} | ${r.action} | ${mdInline(r.from)} | ${mdInline(r.to)} |`);
-		lines.push(``);
-	}
-	lines.push(...coexistingLines);
-	return lines.join("\n").trimEnd();
-};
-/** One-way transform: result to markdown. Encoding back is forbidden. */
-const ChangesetDepsDetectAsMarkdown = ChangesetDepsDetectResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform(renderMarkdown),
-	encode: SchemaGetter.forbidden(() => "ChangesetDepsDetectAsMarkdown is one-way: markdown cannot be parsed back.")
-}));
-/**
 * Effect handler: resolve the workspace root, then compute the cumulative
 * dependency diff via {@link Changesets.DepsRegen.plan} with `includeDevDeps`
 * so devDependency rows are retained. Maps `plan.toWrite` into the structured
@@ -117,14 +73,14 @@ const REMEDIATION = {
 };
 /** The `changeset_deps_detect` tool value. */
 const changesetDepsDetectTool = Tool.make("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.",
+	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. Returns a typed object in structuredContent (content[] carries the same object as JSON).",
 	parameters: ChangesetDepsDetectParams,
 	success: ChangesetDepsDetectResult,
 	failure: McpToolError,
 	dependencies: [WorkspaceRoot, Changesets.DepsRegen]
-}).annotate(Tool.Title, "Detect dependency changesets").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, false).annotate(SilkMarkdown, Schema.decodeUnknownSync(ChangesetDepsDetectAsMarkdown));
+}).annotate(Tool.Title, "Detect dependency changesets").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, false);
 /** Wire handler: {@link changesetDepsDetect} with its error channel mapped onto {@link McpToolError}. */
 const handleChangesetDepsDetect = (fallbackCwd, params) => changesetDepsDetect(params, fallbackCwd).pipe(Effect.mapError(mapEngineError(params.cwd ?? fallbackCwd, REMEDIATION)));
 
 //#endregion
-export { ChangesetDepsDetectAsMarkdown, ChangesetDepsDetectCoexisting, ChangesetDepsDetectPackage, ChangesetDepsDetectParams, ChangesetDepsDetectResult, changesetDepsDetect, changesetDepsDetectTool, handleChangesetDepsDetect };
+export { ChangesetDepsDetectCoexisting, ChangesetDepsDetectPackage, ChangesetDepsDetectParams, ChangesetDepsDetectResult, changesetDepsDetect, changesetDepsDetectTool, handleChangesetDepsDetect };

package/tools/changeset-deps-regen.js

@@ -1,6 +1,5 @@
 import { McpToolError, mapEngineError } from "../errors.js";
-import { SilkMarkdown } from "../markdown.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, Schema } from "effect";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Tool } from "effect/unstable/ai";
@@ -29,51 +28,6 @@ const ChangesetDepsRegenResult = Schema.Struct({
 	description: "Regenerated pure-dependency changesets. Mutates .changeset/*.md unless dryRun is set."
 });
 /**
-* Render a repo-derived value (path) as an inert markdown code span. Control
-* characters are flattened to spaces and the span is fenced with a backtick run
-* longer than any in the value — CommonMark forbids backslash-escaping a
-* backtick inside a code span.
-*/
-const mdInline = (value) => {
-	const safe = value.replace(/\p{Cc}/gu, " ");
-	const longest = safe.match(/`+/g)?.reduce((m, run) => Math.max(m, run.length), 0) ?? 0;
-	const fence = "`".repeat(longest + 1);
-	const pad = safe.startsWith("`") || safe.endsWith("`") || safe.trim() === "" ? " " : "";
-	return `${fence}${pad}${safe}${pad}${fence}`;
-};
-/** Render the structured result as a markdown transcript. */
-const renderMarkdown = (data) => {
-	const heading = `# changeset deps regen — ${mdInline(data.root)}${data.dryRun ? " (dry run)" : ""}`;
-	if (data.deleted.length === 0 && data.written.length === 0 && data.skippedMixed.length === 0 && data.coexisting.length === 0) return `${heading}\n\nNo dependency changes to regenerate.`;
-	const lines = [heading, ``];
-	const verb = data.dryRun ? "Would delete" : "Deleted";
-	if (data.deleted.length > 0) {
-		lines.push(`${verb} ${data.deleted.length} pure dependency changeset(s):`);
-		for (const file of data.deleted) lines.push(`- ${mdInline(file)}`);
-		lines.push(``);
-	}
-	if (data.written.length > 0) {
-		lines.push(`${data.dryRun ? "Would write" : "Wrote"} ${data.written.length} fresh dependency changeset(s):`);
-		for (const file of data.written) lines.push(`- ${mdInline(file)}`);
-		lines.push(``);
-	}
-	if (data.skippedMixed.length > 0) {
-		lines.push(`Skipped ${data.skippedMixed.length} mixed changeset(s):`);
-		for (const file of data.skippedMixed) lines.push(`- ${mdInline(file)}`);
-		lines.push(``);
-	}
-	if (data.coexisting.length > 0) {
-		lines.push(`Coexisting prose changeset(s) for in-scope packages, left untouched:`);
-		for (const entry of data.coexisting) lines.push(`- ${mdInline(entry.file)} (${entry.packages.map(mdInline).join(", ")})`);
-	}
-	return lines.join("\n").trimEnd();
-};
-/** One-way transform: result to markdown. Encoding back is forbidden. */
-const ChangesetDepsRegenAsMarkdown = ChangesetDepsRegenResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform(renderMarkdown),
-	encode: SchemaGetter.forbidden(() => "ChangesetDepsRegenAsMarkdown is one-way: markdown cannot be parsed back.")
-}));
-/**
 * Effect handler: resolve the workspace root, compute a {@link Changesets.RegenPlan}
 * via {@link Changesets.DepsRegen.plan}, then — unless `dryRun` — apply it via
 * `execute`. On a dry run the reported `deleted`/`written` reflect the plan's
@@ -128,14 +82,14 @@ const REMEDIATION = {
 };
 /** The `changeset_deps_regen` tool value. Mutating: not read-only, not idempotent. */
 const changesetDepsRegenTool = Tool.make("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.",
+	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. Returns a typed object in structuredContent (content[] carries the same object as JSON).",
 	parameters: ChangesetDepsRegenParams,
 	success: ChangesetDepsRegenResult,
 	failure: McpToolError,
 	dependencies: [WorkspaceRoot, Changesets.DepsRegen]
-}).annotate(Tool.Title, "Regenerate dependency changesets").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.Idempotent, false).annotate(Tool.OpenWorld, false).annotate(SilkMarkdown, Schema.decodeUnknownSync(ChangesetDepsRegenAsMarkdown));
+}).annotate(Tool.Title, "Regenerate dependency changesets").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.Idempotent, false).annotate(Tool.OpenWorld, false);
 /** Wire handler: {@link changesetDepsRegen} with its error channel mapped onto {@link McpToolError}. */
 const handleChangesetDepsRegen = (fallbackCwd, params) => changesetDepsRegen(params, fallbackCwd).pipe(Effect.mapError(mapEngineError(params.cwd ?? fallbackCwd, REMEDIATION)));
 
 //#endregion
-export { ChangesetCoexistingEntry, ChangesetDepsRegenAsMarkdown, ChangesetDepsRegenParams, ChangesetDepsRegenResult, changesetDepsRegen, changesetDepsRegenTool, handleChangesetDepsRegen };
+export { ChangesetCoexistingEntry, ChangesetDepsRegenParams, ChangesetDepsRegenResult, changesetDepsRegen, changesetDepsRegenTool, handleChangesetDepsRegen };

package/tools/changeset-inspect.js

@@ -1,6 +1,5 @@
 import { McpToolError, mapEngineError } from "../errors.js";
-import { SilkMarkdown } from "../markdown.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, Schema } from "effect";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Tool } from "effect/unstable/ai";
@@ -32,79 +31,6 @@ const ChangesetInspectResult = Schema.Union([
 	description: "Read-only changeset analysis grouped by mode (branch | config | classify)."
 });
 /**
-* Render a repo/config-derived value as an inert markdown code span. Escapes
-* backticks and backslashes so a crafted filename or package name cannot inject
-* markdown structure into the transcript that an agent reads.
-*/
-const mdInline = (value) => `\`${value.replace(/[`\\]/g, "\\$&")}\``;
-/** Render the structured result as a markdown transcript. */
-const renderMarkdown = (data) => {
-	switch (data.mode) {
-		case "branch": {
-			const r = data.result;
-			const lines = [
-				`# changeset branch analysis — base ${mdInline(r.baseBranch)}`,
-				``,
-				`merge base: ${mdInline(r.mergeBaseSha)}`,
-				``,
-				`## Packages affected`,
-				r.packagesAffected.map((p) => `- ${mdInline(p)}`).join("\n") || "(none)",
-				``,
-				`## Files`
-			];
-			for (const f of r.files) {
-				const owner = f.package ? mdInline(f.package) : mdInline("<unmapped>");
-				lines.push(`- ${mdInline(f.status)}  ${mdInline(f.path)}  ->  ${owner}`);
-			}
-			if (r.unmappedFiles.length > 0) {
-				const hints = /* @__PURE__ */ new Map();
-				for (const f of r.files) if (typeof f.reason === "object" && f.reason !== null && f.reason.kind === "unmappedHint") hints.set(f.path, f.reason.hint);
-				lines.push(``, `## Unmapped (ask the user)`);
-				for (const p of r.unmappedFiles) {
-					const hint = hints.get(p);
-					lines.push(hint === void 0 ? `- ${mdInline(p)}` : `- ${mdInline(p)} — ${mdInline(hint)}`);
-				}
-			}
-			return lines.join("\n");
-		}
-		case "config": {
-			const r = data.result;
-			const lines = [
-				`# changeset config — ${mdInline(r.configPath)}`,
-				``,
-				`base branch: ${mdInline(r.baseBranch)}`,
-				`access: ${r.access}`,
-				`changelog: ${r.changelog ? mdInline(r.changelog) : "(none)"}`,
-				`ignored: ${r.ignore.map(mdInline).join(", ") || "(none)"}`,
-				``,
-				`## Packages`
-			];
-			for (const p of r.packages) {
-				lines.push(p.version === void 0 ? `### ${mdInline(p.name)}` : `### ${mdInline(p.name)} (${mdInline(p.version)})`, `- dir: ${mdInline(p.workspaceDir)}`);
-				if (p.additionalScopes.length > 0) lines.push(`- additionalScopes: ${p.additionalScopes.map(mdInline).join(", ")}`);
-				if (p.versionFiles.length > 0) lines.push(`- versionFiles: ${p.versionFiles.map((v) => mdInline(v.glob)).join(", ")}`);
-			}
-			if (r.packages.length === 0) lines.push("(none resolved)");
-			return lines.join("\n");
-		}
-		case "classify": {
-			const lines = [`# changeset classify`, ``];
-			for (const c of data.result) {
-				const owner = c.package ? mdInline(c.package) : mdInline("<unmapped>");
-				const hint = typeof c.reason === "object" && c.reason !== null && c.reason.kind === "unmappedHint" ? ` — ${mdInline(c.reason.hint)}` : "";
-				lines.push(`- ${mdInline(c.path)}  ->  ${owner}${hint}`);
-			}
-			if (data.result.length === 0) lines.push("(no paths)");
-			return lines.join("\n");
-		}
-	}
-};
-/** One-way transform: result to markdown. Encoding back is forbidden. */
-const ChangesetInspectAsMarkdown = ChangesetInspectResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform(renderMarkdown),
-	encode: SchemaGetter.forbidden(() => "ChangesetInspectAsMarkdown is one-way: markdown cannot be parsed back.")
-}));
-/**
 * Effect handler: resolve the workspace root, then dispatch to the matching
 * Changesets service keyed by `mode`. Mirrors `turboInspect`.
 */
@@ -144,7 +70,7 @@ const REMEDIATION = {
 };
 /** The `changeset_inspect` tool value. */
 const changesetInspectTool = Tool.make("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.",
+	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. Returns a typed object in structuredContent (content[] carries the same object as JSON).",
 	parameters: ChangesetInspectParams,
 	success: ChangesetInspectResult,
 	failure: McpToolError,
@@ -153,9 +79,9 @@ const changesetInspectTool = Tool.make("changeset_inspect", {
 		Changesets.ConfigInspector,
 		WorkspaceRoot
 	]
-}).annotate(Tool.Title, "Inspect changesets").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, false).annotate(SilkMarkdown, Schema.decodeUnknownSync(ChangesetInspectAsMarkdown));
+}).annotate(Tool.Title, "Inspect changesets").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, false);
 /** Wire handler: {@link changesetInspect} with its error channel mapped onto {@link McpToolError}. */
 const handleChangesetInspect = (fallbackCwd, params) => changesetInspect(params, fallbackCwd).pipe(Effect.mapError(mapEngineError(params.cwd ?? fallbackCwd, REMEDIATION)));
 
 //#endregion
-export { ChangesetBranchResult, ChangesetClassifyResult, ChangesetConfigResult, ChangesetInspectAsMarkdown, ChangesetInspectParams, ChangesetInspectResult, changesetInspect, changesetInspectTool, handleChangesetInspect };
+export { ChangesetBranchResult, ChangesetClassifyResult, ChangesetConfigResult, ChangesetInspectParams, ChangesetInspectResult, changesetInspect, changesetInspectTool, handleChangesetInspect };

package/tools/changeset-preview.js

@@ -1,6 +1,5 @@
 import { McpToolError, mapEngineError } from "../errors.js";
-import { SilkMarkdown } from "../markdown.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, Schema } from "effect";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Tool } from "effect/unstable/ai";
@@ -12,28 +11,6 @@ const ChangesetPreviewResult = Changesets.ChangesetPreviewSchema.annotate({
 	title: "changeset_preview result",
 	description: "Read-only preview of the next release: version bumps + rendered CHANGELOG blocks."
 });
-/** Render a value as an inert markdown code span (escapes backticks/backslashes). */
-const mdInline = (value) => `\`${value.replace(/[`\\]/g, "\\$&")}\``;
-/** Render the structured preview as a markdown transcript. */
-const renderMarkdown = (data) => {
-	if (data.releases.length === 0) return "# changeset preview\n\nNo pending changesets.";
-	const lines = [
-		`# changeset preview${data.preMode ? ` (pre: ${data.preMode})` : ""}`,
-		``,
-		`## Version bumps`,
-		``
-	];
-	lines.push(`| Package | Old | New | Bump |`, `| --- | --- | --- | --- |`);
-	for (const r of data.releases) lines.push(`| ${mdInline(r.name)} | ${r.oldVersion} | ${r.newVersion} | ${r.type} |`);
-	lines.push(``, `## Release notes`, ``);
-	for (const r of data.releases) lines.push(`### ${mdInline(r.name)}`, ``, r.changelogEntry, ``);
-	return lines.join("\n").trimEnd();
-};
-/** One-way transform: result to markdown. Encoding back is forbidden. */
-const ChangesetPreviewAsMarkdown = ChangesetPreviewResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform(renderMarkdown),
-	encode: SchemaGetter.forbidden(() => "ChangesetPreviewAsMarkdown is one-way: markdown cannot be parsed back.")
-}));
 /**
 * Effect handler: resolve the workspace root, then render the preview via
 * ReleasePlanner. Mirrors `changesetInspect`.
@@ -50,14 +27,14 @@ const REMEDIATION = {
 };
 /** The `changeset_preview` tool value. */
 const changesetPreviewTool = Tool.make("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.",
+	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. Returns a typed object in structuredContent (content[] carries the same object as JSON).",
 	parameters: ChangesetPreviewParams,
 	success: ChangesetPreviewResult,
 	failure: McpToolError,
 	dependencies: [Changesets.ReleasePlanner, WorkspaceRoot]
-}).annotate(Tool.Title, "Preview the next release").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, false).annotate(SilkMarkdown, Schema.decodeUnknownSync(ChangesetPreviewAsMarkdown));
+}).annotate(Tool.Title, "Preview the next release").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, false);
 /** Wire handler: {@link changesetPreview} with its error channel mapped onto {@link McpToolError}. */
 const handleChangesetPreview = (fallbackCwd, params) => changesetPreview(params, fallbackCwd).pipe(Effect.mapError(mapEngineError(params.cwd ?? fallbackCwd, REMEDIATION)));
 
 //#endregion
-export { ChangesetPreviewAsMarkdown, ChangesetPreviewParams, ChangesetPreviewResult, changesetPreview, changesetPreviewTool, handleChangesetPreview };
+export { ChangesetPreviewParams, ChangesetPreviewResult, changesetPreview, changesetPreviewTool, handleChangesetPreview };