@savvy-web/mcp 1.3.5 → 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 and library knowledge to coding agents as structured tools and a curated documentation corpus, so an agent can read workspace facts and Silk docs instead of parsing console output or guessing.
+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
 
@@ -42,21 +42,13 @@ npx @modelcontextprotocol/inspector savvy-mcp .
 ## Tools
 
 - `workspace_info` — returns a flat, structured projection of the workspace analysis: linked and fixed package groups as name arrays plus resolved registry targets. Backed by the same `silk-effects` analyzer the `savvy` CLI uses.
-- `silk_docs_search` — ranks documents in the corpus against a plain keyword or phrase query and returns hits with a normalized confidence score plus a high/medium/low label. A query that matches nothing returns an empty result set, pointing the agent at `silk://catalog` to choose a doc by reasoning.
 - `turbo_inspect` — read-only Turborepo inspection over `turbo --dry`: diagnose a task's per-package cache hits, derive the task graph or list the packages affected by recent changes. It never runs a task. Backed by the same `silk-effects` `Turbo` inspector an agent would otherwise drive by hand.
 - `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.
-
-## Resources
-
-The server exposes a curated markdown corpus behind the `silk://` URI scheme:
-
-- `silk://catalog` — a single fixed resource listing every document grouped by tier with a "load when …" hint. The agent's mandated first read.
-- `silk://{+path}` — a template resolving any document by its stable id, covering Silk development standards (`silk://standards/<topic>`), per-package API and usage docs (`silk://packages/<pkg>/<topic>`) and conceptual guides (`silk://guides/<slug>`).
-
-Per-package API-reference docs under `silk://packages/<pkg>/api/*` are generated from API Extractor models and shipped with the package, with a bare `silk://packages/<pkg>/api` index page listing each package's symbols.
+- `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/bin/savvy-mcp.js

@@ -1,8 +1,6 @@
 #!/usr/bin/env node
 import { SilkRuntimeLive } from "../runtime.js";
-import { loadManifest, readDocBody, resolveContentRoot } from "../resources/load.js";
 import { startMcpServer } from "../server.js";
-import { DocIndex } from "../resources/doc-index.js";
 import { Layer, ManagedRuntime } from "effect";
 import { NodeContext } from "@effect/platform-node";
 
@@ -23,16 +21,9 @@ function resolveProjectDir() {
 async function main() {
 	const cwd = resolveProjectDir();
 	const appLayer = SilkRuntimeLive.pipe(Layer.provide(NodeContext.layer));
-	const runtime = ManagedRuntime.make(appLayer);
-	const contentRoot = resolveContentRoot();
-	const manifest = loadManifest(contentRoot);
-	const bodies = Object.fromEntries(manifest.entries.map((e) => [e.uri, readDocBody(contentRoot, e.uri.replace(/^silk:\/\//, ""))]));
 	const ctx = {
-		runtime,
-		cwd,
-		docIndex: DocIndex.fromManifest(manifest, bodies),
-		manifest,
-		contentRoot
+		runtime: ManagedRuntime.make(appLayer),
+		cwd
 	};
 	process.stderr.write(`[savvy-mcp] starting in ${cwd}\n`);
 	await startMcpServer(ctx);

package/index.d.ts

@@ -1,110 +1,27 @@
 import { Changesets, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
-import { Layer, ManagedRuntime, Schema } from "effect";
+import { Layer, ManagedRuntime } from "effect";
 import { WorkspaceDiscoveryError, WorkspaceRoot } from "workspaces-effect";
-//#region src/resources/schema.d.ts
-/** A manifest entry = decoded front-matter + the derived uri + lastModified. */
-declare const ManifestEntry: Schema.Struct<{
-  id: Schema.filter<typeof Schema.String>;
-  title: typeof Schema.NonEmptyString;
-  summary: typeof Schema.NonEmptyString;
-  tier: Schema.Literal<["standards", "packages", "guides"]>;
-  source: Schema.Literal<["hand", "generated"]>;
-  status: Schema.optionalWith<Schema.Literal<["draft", "stable", "deprecated"]>, {
-    default: () => "stable";
-  }>;
-  supersededBy: Schema.optional<typeof Schema.String>;
-  tags: Schema.Array$<typeof Schema.NonEmptyString>;
-  audience: Schema.optionalWith<Schema.Array$<Schema.Literal<["user", "assistant"]>>, {
-    default: () => ReadonlyArray<"assistant">;
-  }>;
-  priority: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
-    default: () => number;
-  }>;
-  related: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-    default: () => ReadonlyArray<string>;
-  }>;
-  uri: typeof Schema.String;
-  lastModified: Schema.optional<typeof Schema.String>;
-}>;
-type ManifestEntry = Schema.Schema.Type<typeof ManifestEntry>;
-declare const Manifest: Schema.Struct<{
-  entries: Schema.Array$<Schema.Struct<{
-    id: Schema.filter<typeof Schema.String>;
-    title: typeof Schema.NonEmptyString;
-    summary: typeof Schema.NonEmptyString;
-    tier: Schema.Literal<["standards", "packages", "guides"]>;
-    source: Schema.Literal<["hand", "generated"]>;
-    status: Schema.optionalWith<Schema.Literal<["draft", "stable", "deprecated"]>, {
-      default: () => "stable";
-    }>;
-    supersededBy: Schema.optional<typeof Schema.String>;
-    tags: Schema.Array$<typeof Schema.NonEmptyString>;
-    audience: Schema.optionalWith<Schema.Array$<Schema.Literal<["user", "assistant"]>>, {
-      default: () => ReadonlyArray<"assistant">;
-    }>;
-    priority: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
-      default: () => number;
-    }>;
-    related: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-      default: () => ReadonlyArray<string>;
-    }>;
-    uri: typeof Schema.String;
-    lastModified: Schema.optional<typeof Schema.String>;
-  }>>;
-}>;
-type Manifest = Schema.Schema.Type<typeof Manifest>;
-//#endregion
-//#region src/resources/doc-index.d.ts
-interface SearchResult {
-  readonly uri: string;
-  readonly title: string;
-  readonly summary: string;
-  readonly tags: ReadonlyArray<string>;
-  readonly tier: ManifestEntry["tier"];
-  readonly confidence: number;
-  readonly confidenceLabel: "high" | "medium" | "low";
-  readonly matchedOn: ReadonlyArray<string>;
-  readonly related: ReadonlyArray<string>;
-}
-interface SearchOptions {
-  readonly limit?: number;
-  readonly tier?: ManifestEntry["tier"];
-}
-declare class DocIndex {
-  private readonly fuse;
-  private readonly entries;
-  private readonly byUri;
-  private constructor();
-  static fromManifest(manifest: Manifest, bodies: Readonly<Record<string, string>>): DocIndex;
-  search(query: string, opts?: SearchOptions): SearchResult[];
-  /** Browse fallback: surface the top entries (by priority) as low-confidence. */
-  private fallback;
-}
-//#endregion
 //#region src/context.d.ts
-/** The long-lived runtime, the project working directory, and the resource layer. */
+/** 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;
-  readonly docIndex: DocIndex;
-  readonly manifest: Manifest;
-  readonly contentRoot: string;
 }
 //#endregion
 //#region src/runtime.d.ts
 /**
  * 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. */
@@ -120,5 +37,5 @@ declare function startMcpServer(ctx: McpContext): Promise<void>;
  */
 declare const CURRENT_MCP_VERSION = "0.0.0";
 //#endregion
-export { CURRENT_MCP_VERSION, type DocIndex, type Manifest, type ManifestEntry, type McpContext, type SearchOptions, type SearchResult, SilkRuntimeLive, startMcpServer };
+export { CURRENT_MCP_VERSION, type McpContext, SilkRuntimeLive, startMcpServer };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "1.3.5",
+	"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,9 +36,8 @@
 		"@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",
-		"fuse.js": "^7.4.0",
 		"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,11 +1,10 @@
-import { registerAllResources } from "./resources/index.js";
-import { stderrQueryLogger } from "./resources/query-log.js";
 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 { DocsSearchResult, DocsSearchResultAsMarkdown, runDocsSearch } from "./tools/docs-search.js";
 import { TurboInspectAsMarkdown, TurboInspectResult, turboInspect } from "./tools/turbo-inspect.js";
 import { WorkspaceInfoAsMarkdown, WorkspaceInfoResult, workspaceInfo } from "./tools/workspace-info.js";
 import { CURRENT_MCP_VERSION } from "./version.js";
@@ -16,8 +15,8 @@ import { z } from "zod";
 
 //#region src/server.ts
 /**
-* Constructs the MCP server, registers tools and resources, and connects the
-* stdio transport.
+* Constructs the MCP server, registers tools, and connects the stdio
+* transport.
 *
 * @packageDocumentation
 */
@@ -29,7 +28,7 @@ const structuredResult = (text, structured) => ({
 	}],
 	structuredContent: structured
 });
-/** Build the MCP server for the given context, registering tools + resources. */
+/** Build the MCP server for the given context, registering tools. */
 function buildServer(ctx) {
 	const server = new McpServer({
 		name: "savvy-mcp",
@@ -44,26 +43,6 @@ function buildServer(ctx) {
 		const data = await ctx.runtime.runPromise(workspaceInfo(root));
 		return structuredResult(Schema.decodeSync(WorkspaceInfoAsMarkdown)(data), data);
 	});
-	server.registerTool("silk_docs_search", {
-		description: "Search Silk documentation by intent. Pass plain keywords or a short phrase describing what you need (e.g. 'changeset bump rules'). Returns ranked docs with a confidence label; fetch a hit with resources/read <uri>. Read silk://catalog first to orient.",
-		inputSchema: {
-			query: z.string().describe("Keywords or a short phrase describing the doc you need."),
-			limit: z.optional(z.number()).describe("Max results (default 10)."),
-			tier: z.optional(z.enum([
-				"standards",
-				"packages",
-				"guides"
-			])).describe("Restrict to one tier.")
-		},
-		outputSchema: effectToZodSchema(DocsSearchResult),
-		annotations: { readOnlyHint: true }
-	}, async (args) => {
-		const data = runDocsSearch(ctx.docIndex, args.query, {
-			...args.limit !== void 0 ? { limit: args.limit } : {},
-			...args.tier !== void 0 ? { tier: args.tier } : {}
-		}, stderrQueryLogger);
-		return structuredResult(Schema.decodeSync(DocsSearchResultAsMarkdown)(data), 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: {
@@ -112,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.") },
@@ -121,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: {
@@ -135,10 +144,6 @@ function buildServer(ctx) {
 		const data = await runBiomeCheck(args, ctx.cwd);
 		return structuredResult(Schema.decodeSync(BiomeCheckAsMarkdown)(data), data);
 	});
-	registerAllResources(server, {
-		manifest: ctx.manifest,
-		contentRoot: ctx.contentRoot
-	});
 	return server;
 }
 /** Build the server and connect it over stdio. */

package/tools/biome-check.js

@@ -1,8 +1,8 @@
 import { Lint } from "@savvy-web/silk-effects";
 import { ParseResult, Schema } from "effect";
+import { spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
-import { spawnSync } from "node:child_process";
 
 //#region src/tools/biome-check.ts
 /**

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 };

package/content/_templates/guides.md

@@ -1,12 +0,0 @@
-# Guide title
-
-A short intro framing the problem and when to read this guide.
-
-## A section
-
-Free-form prose, lists, and code as the topic demands. Keep each guide a single
-focused page; split when it outgrows the body budget.
-
-## Another section
-
-Close with concrete recommendations or a checklist where it helps.

package/content/_templates/packages.md

@@ -1,21 +0,0 @@
-# Package topic title
-
-## What
-
-One paragraph: what this package or service is and the problem it solves.
-
-## API
-
-The key shapes, signatures, and statics a consumer touches. Condensed, not a full port.
-
-## Layer
-
-The Effect layer(s) and their platform requirements, or the install/build wiring.
-
-## Usage
-
-A short, runnable example of the common path.
-
-## Related
-
-Cross-link sibling digests and the standards they implement.

package/content/_templates/standards.md

@@ -1,17 +0,0 @@
-# Standard title
-
-## Rule
-
-State the durable rule in one or two sentences. This is the thing that must hold.
-
-## Why
-
-Explain the reasoning the rule encodes, so a reader can apply judgment at the edges.
-
-## Examples
-
-Show a conforming case and a non-conforming case.
-
-## See also
-
-Cross-link related standards and package digests by `silk://` URI.