@savvy-web/mcp 2.5.2 → 2.6.1

package/README.md

@@ -43,11 +43,11 @@ npx @modelcontextprotocol/inspector savvy-mcp .
 
 - `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.
 - `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_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 — an unmapped file carries a hint when a configured glob or a known template mirror explains it, and attribution works from a git worktree of the repository — `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.
-- `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`.
+- `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:` specifiers resolve per snapshot side to the range the catalog declares (e.g. `^0.7.0`), while `workspace:` specifiers resolve to the exact workspace version — plus a `coexisting` bucket naming the prose-only changesets that already release an affected package (informational, never touched). 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. Results carry the same `coexisting` bucket as `changeset_deps_detect`. 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.
 - `repos_inspect` — read-only inspection of vendored repositories: `mode=status` reports per-repo presence, the gitlink as a staged/committed/checked-out triple, working-tree dirtiness, and stale note ids; `mode=config` surfaces the validated `.repos/config.json` manifest and its entries; `mode=drift` reconciles the manifest, `.gitmodules`, the worktree, `git submodule status` and the repo's local git config, reporting any mismatch as a typed drift kind; `mode=gitmodules` lists the parsed `.gitmodules` entries. Returns markdown-escaped output since vendored-repo content is untrusted input. Backed by the same `silk-effects` `Repos` services the `savvy` CLI uses.
 - `repos_manage` — manages vendored repositories (mutating counterpart to repos_inspect): `action=sync` initializes any missing submodules (`git submodule update --init --depth 1`), applies sparse-checkout from the manifest, and clears stale git locks; `action=pin` fetches and checks out the new ref, staging the updated gitlink and manifest; `action=add` adds a new repo entry, optionally with the `orientation` block a preceding `remove` reported, so a re-vendor keeps it; `action=note` appends a short note to a repo; `action=remove` unvendors an entry and echoes back the entry it removed; `action=rename` renames one in place; `action=restore` hard-resets one or more dirty checkouts back to their pinned commit, and names any that stayed dirty afterwards instead of reporting the reset as a success. Pin, add, remove and rename stage git changes for the caller to commit; restore only resets the submodule's own working tree to its already-staged or already-committed gitlink commit, so there is nothing new to stage. `sync`, `pin`, `add`, `remove`, `rename` and `restore` unlock the vendored worktree for the duration of their git work and leave it read-only again afterwards (files `0444`, directories `0555` — an executable file locks at `0555` instead, unlocking back to `0755` rather than losing its executable bit), so an agent that hits `EACCES` writing into `.repos/` should route the change through this tool rather than `chmod`. The submodule gitdir stays writable and `sync`/`add` mark the boundary in local git config, so ordinary git commands skip these trees rather than failing against them. Backed by the same `silk-effects` `Repos` services the `savvy` CLI uses.

package/index.d.ts

@@ -34,7 +34,8 @@ interface McpContext {
  * + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
  *
  * @remarks
- * The kit graph (`Workspaces.layerWithGit`) mints a fresh layer reference per
+ * The kit graph (`Workspaces.layerWithGitAndConfigDependenciesSubprocess`)
+ * mints a fresh layer reference per
  * call, so it is bound to a `const` and provided ONCE via `Layer.provideMerge`
  * — layer memoization by reference then constructs each kit service exactly
  * once and exposes `WorkspaceRoot` on the runtime. The same discipline gives

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "2.5.2",
+	"version": "2.6.1",
 	"private": false,
 	"description": "The savvy MCP server — Silk Suite tooling and library knowledge for coding agents",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/mcp",
@@ -33,10 +33,10 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.109",
 		"@effected/commands": "^0.5.0",
-		"@effected/git": "^0.9.0",
-		"@effected/workspaces": "^0.17.2",
+		"@effected/git": "^0.10.0",
+		"@effected/workspaces": "^0.18.1",
 		"@modelcontextprotocol/sdk": "^1.30.0",
-		"@savvy-web/silk-effects": "7.0.1",
+		"@savvy-web/silk-effects": "7.1.1",
 		"effect": "4.0.0-rc.109",
 		"zod": "^4.4.3"
 	}

package/runtime.js

@@ -25,7 +25,8 @@ import { Effect, Layer } from "effect";
 * + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
 *
 * @remarks
-* The kit graph (`Workspaces.layerWithGit`) mints a fresh layer reference per
+* The kit graph (`Workspaces.layerWithGitAndConfigDependenciesSubprocess`)
+* mints a fresh layer reference per
 * call, so it is bound to a `const` and provided ONCE via `Layer.provideMerge`
 * — layer memoization by reference then constructs each kit service exactly
 * once and exposes `WorkspaceRoot` on the runtime. The same discipline gives
@@ -39,7 +40,7 @@ import { Effect, Layer } from "effect";
 * ignored", identical to the savvy CLI).
 */
 const makeSilkRuntimeLayer = (cwd) => {
-	const kitGraph = Workspaces.layerWithGit({ cwd });
+	const kitGraph = Workspaces.layerWithGitAndConfigDependenciesSubprocess({ cwd });
 	const analyzerDeps = ChangesetConfigReader.layer;
 	/**
 	* `BranchAnalyzer` + `ReleasePlanner` + the ONE shared `ConfigInspector`,

package/server.js

@@ -77,7 +77,7 @@ function buildServer(ctx) {
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_inspect", {
-		description: "Read-only changeset analysis for the changeset-manager workflow. mode=branch diffs the current branch against its base and classifies every changed file by owning package (with packagesAffected and the unmapped paths to ask the user about). 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.",
 		inputSchema: {
 			mode: z.enum([
 				"branch",
@@ -109,7 +109,7 @@ function buildServer(ctx) {
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_deps_detect", {
-		description: "Read-only preview of the cumulative dependency diff (merge-base -> working tree) per workspace package. Returns each affected package's resolved dependency-table rows (catalog:/workspace: specifiers resolved 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.",
+		description: "Read-only preview of the cumulative dependency diff (merge-base -> working tree) per workspace package. Returns each affected package's resolved dependency-table rows (catalog:/workspace: specifiers resolved per side; devDependencies retained) as the exact rows a pure-dependency changeset would carry, plus a coexisting list of untouched prose-only changesets that reference an in-scope package (informational — no need to re-list .changeset/). Does NOT write or delete any file. Prefer this over shelling out to savvy changeset deps detect.",
 		inputSchema: {
 			base: z.optional(z.string()).describe("Override the base branch used to compute the merge-base."),
 			package: z.optional(z.string()).describe("Restrict output to a single workspace package."),
@@ -135,7 +135,7 @@ function buildServer(ctx) {
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_deps_regen", {
-		description: "Regenerate pure-dependency changesets: delete stale single-package Dependencies-only changesets and write fresh single-package, patch-bump changesets from the cumulative dependency diff (catalog:/workspace: resolved; devDependencies dropped). Mixed changesets (Dependencies plus other content) are left untouched. 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.",
 		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."),

package/tools/changeset-deps-detect.js

@@ -9,10 +9,20 @@ const ChangesetDepsDetectPackage = Schema.Struct({
 	relativePath: Schema.String,
 	rows: Schema.Array(Changesets.DependencyTableRowSchema)
 }).annotate({ identifier: "ChangesetDepsDetectPackage" });
+/**
+* An untouched prose-only changeset releasing a package in scope for the run
+* (#279) — informational, so the result accounts for every changeset touching
+* an in-scope package.
+*/
+const ChangesetDepsDetectCoexisting = Schema.Struct({
+	file: Schema.String,
+	packages: Schema.Array(Schema.String)
+}).annotate({ identifier: "ChangesetDepsDetectCoexisting" });
 /** The `changeset_deps_detect` tool result. */
 const ChangesetDepsDetectResult = Schema.Struct({
 	root: Schema.String,
-	packages: Schema.Array(ChangesetDepsDetectPackage)
+	packages: Schema.Array(ChangesetDepsDetectPackage),
+	coexisting: Schema.Array(ChangesetDepsDetectCoexisting).annotate({ description: "Prose-only changesets referencing an in-scope package (no Dependencies section). Informational — a regen run would leave these untouched." })
 }).annotate({
 	identifier: "ChangesetDepsDetectResult",
 	title: "changeset_deps_detect result",
@@ -35,7 +45,17 @@ const mdInline = (value) => {
 };
 /** 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 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)}`, ``);
@@ -43,6 +63,7 @@ const renderMarkdown = (data) => {
 		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. */
@@ -58,22 +79,27 @@ const ChangesetDepsDetectAsMarkdown = ChangesetDepsDetectResult.pipe(Schema.deco
 */
 const changesetDepsDetect = (args, fallbackCwd) => Effect.gen(function* () {
 	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
+	const plan = yield* (yield* Changesets.DepsRegen).plan({
+		cwd: root,
+		includeDevDeps: true,
+		...args.base ? { base: args.base } : {},
+		...args.package ? { package: args.package } : {},
+		...args.packages && args.packages.length > 0 ? { packages: args.packages } : {},
+		...args.exclude && args.exclude.length > 0 ? { exclude: args.exclude } : {}
+	});
 	return {
 		root,
-		packages: (yield* (yield* Changesets.DepsRegen).plan({
-			cwd: root,
-			includeDevDeps: true,
-			...args.base ? { base: args.base } : {},
-			...args.package ? { package: args.package } : {},
-			...args.packages && args.packages.length > 0 ? { packages: args.packages } : {},
-			...args.exclude && args.exclude.length > 0 ? { exclude: args.exclude } : {}
-		})).toWrite.map((entry) => ({
+		packages: plan.toWrite.map((entry) => ({
 			package: entry.diff.package,
 			relativePath: entry.diff.relativePath,
 			rows: entry.diff.rows
+		})),
+		coexisting: plan.coexisting.map((entry) => ({
+			file: entry.file,
+			packages: [...entry.packages]
 		}))
 	};
 });
 
 //#endregion
-export { ChangesetDepsDetectAsMarkdown, ChangesetDepsDetectPackage, ChangesetDepsDetectResult, changesetDepsDetect };
+export { ChangesetDepsDetectAsMarkdown, ChangesetDepsDetectCoexisting, ChangesetDepsDetectPackage, ChangesetDepsDetectResult, changesetDepsDetect };

package/tools/changeset-deps-regen.js

@@ -3,12 +3,22 @@ import { Changesets } from "@savvy-web/silk-effects";
 import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/changeset-deps-regen.ts
+/**
+* An untouched prose-only changeset releasing a package in scope for the run
+* (#279) — informational, so the result accounts for every changeset touching
+* an in-scope package.
+*/
+const ChangesetCoexistingEntry = Schema.Struct({
+	file: Schema.String,
+	packages: Schema.Array(Schema.String)
+}).annotate({ identifier: "ChangesetCoexistingEntry" });
 /** 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),
+	coexisting: Schema.Array(ChangesetCoexistingEntry).annotate({ description: "Prose-only changesets referencing an in-scope package that this run left untouched (no Dependencies section). Informational — no need to re-list .changeset/ to confirm a package's full changeset picture." }),
 	dryRun: Schema.Boolean
 }).annotate({
 	identifier: "ChangesetDepsRegenResult",
@@ -31,7 +41,7 @@ const mdInline = (value) => {
 /** 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.`;
+	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) {
@@ -47,6 +57,11 @@ const renderMarkdown = (data) => {
 	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();
 };
@@ -76,6 +91,10 @@ const changesetDepsRegen = (args, fallbackCwd) => Effect.gen(function* () {
 		deleted: plan.toDelete.map((entry) => entry.file),
 		written: plan.toWrite.map((entry) => entry.file),
 		skippedMixed: [...plan.skippedMixed],
+		coexisting: plan.coexisting.map((entry) => ({
+			file: entry.file,
+			packages: [...entry.packages]
+		})),
 		dryRun: true
 	};
 	const result = yield* service.execute(plan);
@@ -84,9 +103,13 @@ const changesetDepsRegen = (args, fallbackCwd) => Effect.gen(function* () {
 		deleted: [...result.deleted],
 		written: [...result.written],
 		skippedMixed: [...result.skippedMixed],
+		coexisting: result.coexisting.map((entry) => ({
+			file: entry.file,
+			packages: [...entry.packages]
+		})),
 		dryRun: false
 	};
 });
 
 //#endregion
-export { ChangesetDepsRegenAsMarkdown, ChangesetDepsRegenResult, changesetDepsRegen };
+export { ChangesetCoexistingEntry, ChangesetDepsRegenAsMarkdown, ChangesetDepsRegenResult, changesetDepsRegen };

package/tools/changeset-inspect.js

@@ -54,8 +54,13 @@ const renderMarkdown = (data) => {
 				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) lines.push(`- ${mdInline(p)}`);
+				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");
 		}
@@ -83,7 +88,8 @@ const renderMarkdown = (data) => {
 			const lines = [`# changeset classify`, ``];
 			for (const c of data.result) {
 				const owner = c.package ? mdInline(c.package) : mdInline("<unmapped>");
-				lines.push(`- ${mdInline(c.path)}  ->  ${owner}`);
+				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");
@@ -102,7 +108,7 @@ const ChangesetInspectAsMarkdown = ChangesetInspectResult.pipe(Schema.decodeTo(S
 const changesetInspect = (args, fallbackCwd) => Effect.gen(function* () {
 	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
 	const inspector = yield* Changesets.ConfigInspector;
-	yield* inspector.refresh();
+	yield* inspector.refreshIn(root);
 	switch (args.mode) {
 		case "branch": return {
 			mode: "branch",