@savvy-web/mcp 1.4.0 → 1.5.0

package/README.md

@@ -3,7 +3,7 @@
 [![npm](https://img.shields.io/npm/v/@savvy-web%2Fmcp?label=npm&color=cb3837)](https://www.npmjs.com/package/@savvy-web/mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
 
-The `savvy-mcp` [Model Context Protocol](https://modelcontextprotocol.io/) server. It serves [Silk Suite](https://github.com/savvy-web/systems) tooling to coding agents as structured tools, so an agent can read workspace facts and run Silk checks instead of parsing console output or guessing. It is a tools-only server — six tools, no resources.
+The `savvy-mcp` [Model Context Protocol](https://modelcontextprotocol.io/) server. It serves [Silk Suite](https://github.com/savvy-web/systems) tooling to coding agents as structured tools, so an agent can read workspace facts and run Silk checks instead of parsing console output or guessing. It is a tools-only server — eight tools, no resources.
 
 ## Install
 
@@ -46,7 +46,9 @@ npx @modelcontextprotocol/inspector savvy-mcp .
 - `changeset_inspect` — read-only changeset analysis for release work: `mode=branch` diffs the current branch against its base and attributes every changed file to its owning package, `mode=config` surfaces the resolved `.changeset/config.json` with its release surfaces, version files and ignore list, and `mode=classify` reports how the branch's pending changesets classify each package's bump. It never writes a changeset. Backed by the same `silk-effects` changeset services the `savvy` CLI uses.
 - `changeset_validate` — read-only validation of the files in a changeset directory against the section-aware rules, returning typed diagnostics (file, rule, line, column, message) plus an ok flag and error count. Use it instead of shelling out to `savvy changeset lint`.
 - `changeset_preview` — read-only preview of the next release: it runs the genuine changesets engine over the pending changesets and returns each package's version bump (old to new) plus the rendered CHANGELOG block, exactly as it would ship. It never mutates the repo. Backed by the same `silk-effects` release planner the `savvy changeset version` command applies.
-- `biome_check` — run Biome over a path and get structured diagnostics back: `mode=check` (lint, format and organize-imports) or `mode=lint`. Unlike the other tools it can mutate — pass `write` for safe fixes or `unsafe` for unsafe ones (both git-reversible) — so it returns the same diagnostics the Biome LSP surfaces for files you have edited.
+- `changeset_deps_detect` — read-only preview of the cumulative dependency diff (merge-base to working tree): one entry per affected workspace package with its resolved dependency-table rows, `catalog:`/`workspace:` specifiers resolved to concrete versions. It never writes a changeset. Backed by `silk-effects`' `Changesets.DepsRegen.plan`.
+- `changeset_deps_regen` — regenerates pure-dependency changesets: deletes stale ones and writes fresh single-package, patch-bump changesets from the cumulative dependency diff. Mutating unless `dryRun` is set, in which case it reports what it would delete and write without touching the filesystem. Backed by `silk-effects`' `Changesets.DepsRegen`.
+- `biome_check` — run Biome over a path and get structured diagnostics back: `mode=check` (lint, format and organize-imports) or `mode=lint`. Unlike most of the other tools it can mutate — pass `write` for safe fixes or `unsafe` for unsafe ones (both git-reversible) — so it returns the same diagnostics the Biome LSP surfaces for files you have edited.
 
 ## License
 

package/index.d.ts

@@ -4,7 +4,7 @@ import { WorkspaceDiscoveryError, WorkspaceRoot } from "workspaces-effect";
 //#region src/context.d.ts
 /** The long-lived runtime and the project working directory. */
 interface McpContext {
-  readonly runtime: ManagedRuntime.ManagedRuntime<SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner, WorkspaceDiscoveryError>;
+  readonly runtime: ManagedRuntime.ManagedRuntime<SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner | Changesets.DepsRegen, WorkspaceDiscoveryError>;
   readonly cwd: string;
 }
 //#endregion
@@ -12,16 +12,16 @@ interface McpContext {
 /**
  * The MCP runtime layer. Provides `SilkWorkspaceAnalyzer`, `WorkspaceRoot`,
  * `Turbo.TurboInspector`, `Changesets.BranchAnalyzer`,
- * `Changesets.ConfigInspector`, and `Changesets.ReleasePlanner`; requires
- * `CommandExecutor` + `FileSystem` + `Path` from the host's platform layer
- * (`NodeContext.layer` in bin.ts).
+ * `Changesets.ConfigInspector`, `Changesets.ReleasePlanner`, and
+ * `Changesets.DepsRegen`; requires `CommandExecutor` + `FileSystem` + `Path`
+ * from the host's platform layer (`NodeContext.layer` in bin.ts).
  *
  * `TurboInspectorLive` is fed its own `ToolDiscoveryLive`, whose
  * `PackageManagerDetector` + `WorkspaceRoot` requirements are satisfied by
  * {@link DepsLive}; the leftover `CommandExecutor` + `FileSystem` flow up to the
  * host platform layer.
  */
-declare const SilkRuntimeLive: Layer.Layer<Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner | import("@savvy-web/silk-effects").SilkWorkspaceAnalyzer | Turbo.TurboInspector | import("workspaces-effect").WorkspaceRoot, import("workspaces-effect").WorkspaceDiscoveryError, import("@effect/platform/CommandExecutor").CommandExecutor | import("@effect/platform/FileSystem").FileSystem | import("@effect/platform/Path").Path>;
+declare const SilkRuntimeLive: Layer.Layer<Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.DepsRegen | Changesets.ReleasePlanner | import("@savvy-web/silk-effects").SilkWorkspaceAnalyzer | Turbo.TurboInspector | import("workspaces-effect").WorkspaceRoot, import("workspaces-effect").WorkspaceDiscoveryError, import("@effect/platform/CommandExecutor").CommandExecutor | import("@effect/platform/FileSystem").FileSystem | import("@effect/platform/Path").Path>;
 //#endregion
 //#region src/server.d.ts
 /** Build the server and connect it over stdio. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "1.4.0",
+	"version": "1.5.0",
 	"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",
@@ -36,7 +36,7 @@
 		"@effect/rpc": "^0.75.1",
 		"@effect/sql": "^0.51.1",
 		"@modelcontextprotocol/sdk": "^1.29.0",
-		"@savvy-web/silk-effects": "1.5.2",
+		"@savvy-web/silk-effects": "1.6.0",
 		"effect": "^3.21.4",
 		"workspaces-effect": "^1.2.0",
 		"zod": "^4.4.3"

package/runtime.js

@@ -24,18 +24,36 @@ import { WorkspaceRootLive, WorkspacesLive } from "workspaces-effect";
 const DepsLive = Layer.mergeAll(WorkspacesLive, ChangesetConfigReaderLive, TagStrategyLive, VersioningStrategyLive.pipe(Layer.provide(ChangesetConfigReaderLive)));
 const InspectorAndAnalyzerLive = Changesets.BranchAnalyzerLive.pipe(Layer.provideMerge(Changesets.ReleasePlannerLive), Layer.provideMerge(Changesets.ConfigInspectorLive));
 /**
+* `Changesets.DepsRegen` (the `changeset_deps_detect` / `changeset_deps_regen`
+* orchestration service), fully composed except for the services supplied by
+* {@link DepsLive} / the host platform layer.
+*
+* `DepsRegenLive` requires `WorkspaceSnapshotReader | ConfigInspector |
+* WorkspaceDiscovery | CatalogResolver | PublishabilityDetector`. Here
+* `ConfigInspector` is provided via the shared {@link InspectorAndAnalyzerLive}
+* reference (so Effect memoizes the single `ConfigInspector` instance already
+* merged into the runtime), and `WorkspaceSnapshotReader` via the
+* dependency-free {@link Changesets.WorkspaceSnapshotReaderLive}. The remaining
+* three — `WorkspaceDiscovery`, `CatalogResolver`, `PublishabilityDetector` —
+* are left open and satisfied by `WorkspacesLive` inside {@link DepsLive}
+* (unlike the CLI, whose minimal workspace trio has to compose
+* `CatalogResolverLive`/`PublishabilityDetectorLive` by hand). `FileSystem` /
+* `Path` / `CommandExecutor` flow up to the host `NodeContext.layer`.
+*/
+const DepsRegenGroupLive = Changesets.DepsRegenLive.pipe(Layer.provide(InspectorAndAnalyzerLive), Layer.provide(Changesets.WorkspaceSnapshotReaderLive));
+/**
 * The MCP runtime layer. Provides `SilkWorkspaceAnalyzer`, `WorkspaceRoot`,
 * `Turbo.TurboInspector`, `Changesets.BranchAnalyzer`,
-* `Changesets.ConfigInspector`, and `Changesets.ReleasePlanner`; requires
-* `CommandExecutor` + `FileSystem` + `Path` from the host's platform layer
-* (`NodeContext.layer` in bin.ts).
+* `Changesets.ConfigInspector`, `Changesets.ReleasePlanner`, and
+* `Changesets.DepsRegen`; requires `CommandExecutor` + `FileSystem` + `Path`
+* from the host's platform layer (`NodeContext.layer` in bin.ts).
 *
 * `TurboInspectorLive` is fed its own `ToolDiscoveryLive`, whose
 * `PackageManagerDetector` + `WorkspaceRoot` requirements are satisfied by
 * {@link DepsLive}; the leftover `CommandExecutor` + `FileSystem` flow up to the
 * host platform layer.
 */
-const SilkRuntimeLive = Layer.mergeAll(SilkWorkspaceAnalyzerLive, WorkspaceRootLive, Turbo.TurboInspectorLive.pipe(Layer.provide(ToolDiscoveryLive)), InspectorAndAnalyzerLive).pipe(Layer.provide(DepsLive));
+const SilkRuntimeLive = Layer.mergeAll(SilkWorkspaceAnalyzerLive, WorkspaceRootLive, Turbo.TurboInspectorLive.pipe(Layer.provide(ToolDiscoveryLive)), InspectorAndAnalyzerLive, DepsRegenGroupLive).pipe(Layer.provide(DepsLive));
 
 //#endregion
 export { SilkRuntimeLive };

package/server.js

@@ -1,5 +1,7 @@
 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";
@@ -89,6 +91,19 @@ function buildServer(ctx) {
 		const data = await ctx.runtime.runPromise(changesetValidate(args, ctx.cwd));
 		return structuredResult(Schema.decodeSync(ChangesetValidateAsMarkdown)(data), 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 to concrete versions; devDependencies retained) as the exact rows a pure-dependency changeset would carry. 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."),
+			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));
+		return structuredResult(Schema.decodeSync(ChangesetDepsDetectAsMarkdown)(data), 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.") },
@@ -98,6 +113,23 @@ function buildServer(ctx) {
 		const data = await ctx.runtime.runPromise(changesetPreview(args, ctx.cwd));
 		return structuredResult(Schema.decodeSync(ChangesetPreviewAsMarkdown)(data), 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. 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."),
+			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));
+		return structuredResult(Schema.decodeSync(ChangesetDepsRegenAsMarkdown)(data), 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). 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: {

package/tools/changeset-deps-detect.js

@@ -0,0 +1,88 @@
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect, ParseResult, Schema } from "effect";
+import { WorkspaceRoot } from "workspaces-effect";
+
+//#region src/tools/changeset-deps-detect.ts
+/**
+* The `changeset_deps_detect` MCP tool: a read-only preview of the cumulative
+* dependency diff (merge-base → working tree) over silk-effects'
+* `Changesets.DepsRegen.plan`. Returns one entry per affected workspace package
+* — its resolved dependency-table rows (devDependencies retained) — plus a
+* one-way markdown transform. Read-only: no changeset file is written or
+* deleted.
+*
+* @packageDocumentation
+*/
+/** One affected workspace package's resolved dependency diff. */
+const ChangesetDepsDetectPackage = Schema.Struct({
+	package: Schema.String,
+	relativePath: Schema.String,
+	rows: Schema.Array(Changesets.DependencyTableRowSchema)
+}).annotations({ identifier: "ChangesetDepsDetectPackage" });
+/** The `changeset_deps_detect` tool result. */
+const ChangesetDepsDetectResult = Schema.Struct({
+	root: Schema.String,
+	packages: Schema.Array(ChangesetDepsDetectPackage)
+}).annotations({
+	identifier: "ChangesetDepsDetectResult",
+	title: "changeset_deps_detect result",
+	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) => {
+	if (data.packages.length === 0) return `# changeset deps detect — ${mdInline(data.root)}\n\nNo dependency changes detected.`;
+	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(``);
+	}
+	return lines.join("\n").trimEnd();
+};
+/** One-way transform: result to markdown. Encoding back is forbidden. */
+const ChangesetDepsDetectAsMarkdown = Schema.transformOrFail(ChangesetDepsDetectResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "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
+* result. No filesystem mutation happens (no `execute`).
+*/
+const changesetDepsDetect = (args, fallbackCwd) => Effect.gen(function* () {
+	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
+	return {
+		root,
+		packages: (yield* (yield* Changesets.DepsRegen).plan({
+			cwd: root,
+			includeDevDeps: true,
+			...args.base ? { base: args.base } : {},
+			...args.package ? { package: args.package } : {}
+		})).toWrite.map((entry) => ({
+			package: entry.diff.package,
+			relativePath: entry.diff.relativePath,
+			rows: entry.diff.rows
+		}))
+	};
+});
+
+//#endregion
+export { ChangesetDepsDetectAsMarkdown, ChangesetDepsDetectPackage, ChangesetDepsDetectResult, changesetDepsDetect };

package/tools/changeset-deps-regen.js

@@ -0,0 +1,100 @@
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect, ParseResult, Schema } from "effect";
+import { WorkspaceRoot } from "workspaces-effect";
+
+//#region src/tools/changeset-deps-regen.ts
+/**
+* The `changeset_deps_regen` MCP tool: delete stale pure-dependency changesets
+* and write fresh single-package, patch-bump changesets from the cumulative
+* dependency diff, over silk-effects' `Changesets.DepsRegen`. Mutating (writes
+* and deletes `.changeset/*.md`) unless `dryRun` is set. The second mutating
+* tool after `biome_check`; no `readOnlyHint`.
+*
+* @packageDocumentation
+*/
+/** The `changeset_deps_regen` tool result. */
+const ChangesetDepsRegenResult = Schema.Struct({
+	root: Schema.String,
+	deleted: Schema.Array(Schema.String),
+	written: Schema.Array(Schema.String),
+	skippedMixed: Schema.Array(Schema.String),
+	dryRun: Schema.Boolean
+}).annotations({
+	identifier: "ChangesetDepsRegenResult",
+	title: "changeset_deps_regen result",
+	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) 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)}`);
+	}
+	return lines.join("\n").trimEnd();
+};
+/** One-way transform: result to markdown. Encoding back is forbidden. */
+const ChangesetDepsRegenAsMarkdown = Schema.transformOrFail(ChangesetDepsRegenResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "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
+* intended files without touching the filesystem.
+*/
+const changesetDepsRegen = (args, fallbackCwd) => Effect.gen(function* () {
+	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
+	const service = yield* Changesets.DepsRegen;
+	const plan = yield* service.plan({
+		cwd: root,
+		...args.base ? { base: args.base } : {},
+		...args.package ? { package: args.package } : {}
+	});
+	if (args.dryRun === true) return {
+		root,
+		deleted: plan.toDelete.map((entry) => entry.file),
+		written: plan.toWrite.map((entry) => entry.file),
+		skippedMixed: [...plan.skippedMixed],
+		dryRun: true
+	};
+	const result = yield* service.execute(plan);
+	return {
+		root,
+		deleted: [...result.deleted],
+		written: [...result.written],
+		skippedMixed: [...result.skippedMixed],
+		dryRun: false
+	};
+});
+
+//#endregion
+export { ChangesetDepsRegenAsMarkdown, ChangesetDepsRegenResult, changesetDepsRegen };