@savvy-web/mcp 0.4.1 → 0.5.0

package/README.md

@@ -44,6 +44,7 @@ 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.
 - `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. It never returns empty: when nothing matches, it falls back to the priority-ordered top results.
 - `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. It never writes a changeset. Backed by the same `silk-effects` changeset services the `savvy` CLI uses.
 
 ## Resources
 

package/bin/savvy-mcp.d.ts

@@ -0,0 +1 @@
+export { };

package/index.d.ts

@@ -0,0 +1,123 @@
+import { Changesets, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
+import { Layer, ManagedRuntime, Schema } 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<{
+  uri: typeof Schema.String;
+  lastModified: Schema.optional<typeof Schema.String>;
+  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>;
+  }>;
+}>;
+type ManifestEntry = Schema.Schema.Type<typeof ManifestEntry>;
+declare const Manifest: Schema.Struct<{
+  entries: Schema.Array$<Schema.Struct<{
+    uri: typeof Schema.String;
+    lastModified: Schema.optional<typeof Schema.String>;
+    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>;
+    }>;
+  }>>;
+}>;
+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[];
+  /** Never return empty: 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. */
+interface McpContext {
+  readonly runtime: ManagedRuntime.ManagedRuntime<SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector, 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`, and
+ * `Changesets.ConfigInspector`; 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<import("@savvy-web/silk-effects").SilkWorkspaceAnalyzer | import("workspaces-effect").WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector, import("workspaces-effect").WorkspaceDiscoveryError, import("@effect/platform/FileSystem").FileSystem | import("@effect/platform/Path").Path | import("@effect/platform/CommandExecutor").CommandExecutor>;
+//#endregion
+//#region src/server.d.ts
+/** Build the server and connect it over stdio. */
+declare function startMcpServer(ctx: McpContext): Promise<void>;
+//#endregion
+//#region src/version.d.ts
+/**
+ * The package version, replaced at build time. `0.0.0` in dev/test indicates
+ * an unbuilt source run. Kept in its own module so both `server.ts` and the
+ * `index.ts` barrel can import it without forming an import cycle.
+ *
+ * @packageDocumentation
+ */
+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 };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,5 @@
+import { SilkRuntimeLive } from "./runtime.js";
+import { CURRENT_MCP_VERSION } from "./version.js";
+import { startMcpServer } from "./server.js";
+
+export { CURRENT_MCP_VERSION, SilkRuntimeLive, startMcpServer };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "0.4.1",
+	"version": "0.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",
@@ -23,20 +23,18 @@
 		".": {
 			"types": "./index.d.ts",
 			"import": "./index.js"
-		}
+		},
+		"./package.json": "./package.json"
 	},
 	"bin": {
 		"savvy-mcp": "bin/savvy-mcp.js"
 	},
-	"files": [
-		"public"
-	],
 	"dependencies": {
 		"@effect/platform": "^0.96.1",
-		"@effect/platform-node": "^0.106.0",
+		"@effect/platform-node": "^0.107.0",
 		"@modelcontextprotocol/sdk": "^1.29.0",
-		"@savvy-web/silk-effects": "1.0.1",
-		"effect": "^3.21.2",
+		"@savvy-web/silk-effects": "1.1.0",
+		"effect": "^3.21.3",
 		"fuse.js": "^7.4.0",
 		"workspaces-effect": "^1.2.0",
 		"zod": "^4.4.3"

package/resources/catalog.js

@@ -0,0 +1,29 @@
+//#region src/resources/catalog.ts
+const TIER_HEADINGS = [
+	["standards", "Standards"],
+	["packages", "Packages"],
+	["guides", "Guides"]
+];
+function renderCatalogMarkdown(manifest) {
+	const lines = [
+		"# silk://catalog",
+		"",
+		"Read this first to orient. To fetch a doc, call `resources/read` with its `silk://` URI.",
+		"To search by intent, use the `silk_docs_search` tool.",
+		""
+	];
+	for (const [tier, heading] of TIER_HEADINGS) {
+		const entries = manifest.entries.filter((e) => e.tier === tier && e.status !== "deprecated");
+		if (entries.length === 0) continue;
+		lines.push(`## ${heading}`, "");
+		for (const e of entries) {
+			const gen = e.source === "generated" ? " (generated)" : "";
+			lines.push(`- \`${e.uri}\`${gen} — ${e.title}. load when: ${e.summary}`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+export { renderCatalogMarkdown };

package/resources/doc-index.js

@@ -0,0 +1,112 @@
+import Fuse from "fuse.js";
+
+//#region src/resources/doc-index.ts
+const STOP_WORDS = new Set([
+	"how",
+	"do",
+	"i",
+	"the",
+	"a",
+	"an",
+	"to",
+	"of",
+	"in",
+	"for",
+	"is",
+	"what",
+	"when",
+	"use"
+]);
+const FUSE_THRESHOLD = .6;
+const confidenceLabel = (confidence) => confidence >= .6 ? "high" : confidence >= .4 ? "medium" : "low";
+const toRanked = (item, score, matches) => ({
+	item,
+	confidence: 1 - (score ?? 1),
+	matchedOn: matches.map((m) => m.key ?? "")
+});
+var DocIndex = class DocIndex {
+	fuse;
+	entries;
+	byUri;
+	constructor(fuse, entries, byUri) {
+		this.fuse = fuse;
+		this.entries = entries;
+		this.byUri = byUri;
+	}
+	static fromManifest(manifest, bodies) {
+		const entries = manifest.entries.filter((e) => e.status !== "deprecated").map((e) => ({
+			...e,
+			body: bodies[e.uri] ?? ""
+		}));
+		return new DocIndex(new Fuse(entries, {
+			useExtendedSearch: true,
+			ignoreLocation: true,
+			includeScore: true,
+			includeMatches: true,
+			minMatchCharLength: 2,
+			threshold: FUSE_THRESHOLD,
+			keys: [
+				{
+					name: "title",
+					weight: .55
+				},
+				{
+					name: "tags",
+					weight: .3
+				},
+				{
+					name: "summary",
+					weight: .12
+				},
+				{
+					name: "body",
+					weight: .03
+				}
+			]
+		}), entries, new Map(entries.map((e) => [e.uri, e])));
+	}
+	search(query, opts = {}) {
+		const limit = opts.limit ?? 10;
+		const tokens = query.toLowerCase().split(/\s+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+		const raw = tokens.length > 0 ? this.fuse.search(tokens.map((t) => `'${t}`).join(" | ")) : [];
+		const filteredByTier = opts.tier ? raw.filter((r) => r.item.tier === opts.tier) : raw;
+		const ranked = filteredByTier.length > 0 ? filteredByTier.map((r) => toRanked(r.item, r.score, r.matches ?? [])) : this.fallback(opts.tier);
+		ranked.sort((a, b) => b.confidence - a.confidence || (b.item.priority ?? .5) - (a.item.priority ?? .5));
+		const present = new Set(ranked.map((r) => r.item.uri));
+		const seeAlso = [];
+		for (const r of ranked.slice(0, 3)) for (const rel of r.item.related) {
+			const uri = rel.startsWith("silk://") ? rel : `silk://${rel}`;
+			if (present.has(uri)) continue;
+			const neighbor = this.byUri.get(uri);
+			if (!neighbor) continue;
+			present.add(uri);
+			seeAlso.push({
+				item: neighbor,
+				confidence: 0,
+				matchedOn: ["related"]
+			});
+		}
+		return [...ranked, ...seeAlso].slice(0, limit).map(({ item, confidence, matchedOn }) => ({
+			uri: item.uri,
+			title: item.title,
+			summary: item.summary,
+			tags: item.tags,
+			tier: item.tier,
+			confidence: Number(confidence.toFixed(3)),
+			confidenceLabel: confidenceLabel(confidence),
+			matchedOn: [...new Set(matchedOn)].filter(Boolean),
+			related: item.related
+		}));
+	}
+	/** Never return empty: surface the top entries (by priority) as low-confidence. */
+	fallback(tier) {
+		return this.entries.filter((e) => tier ? e.tier === tier : true).slice().sort((a, b) => (b.priority ?? .5) - (a.priority ?? .5)).slice(0, 5).map((item) => ({
+			item,
+			confidence: 0,
+			matchedOn: []
+		}));
+	}
+};
+
+//#endregion
+export { DocIndex };

package/resources/index.js

@@ -0,0 +1,48 @@
+import { renderCatalogMarkdown } from "./catalog.js";
+import { readDocBody } from "./load.js";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/resources/index.ts
+const resourceName = (entry) => `silk_${entry.id.replace(/[^A-Za-z0-9]/g, "_")}`;
+const toSdkAnnotations = (e) => ({
+	audience: [...e.audience],
+	priority: e.priority,
+	...e.lastModified ? { lastModified: e.lastModified } : {}
+});
+function registerAllResources(server, deps) {
+	const { manifest, bodies, contentRoot } = deps;
+	server.registerResource("silk_catalog", "silk://catalog", {
+		title: "Silk resource catalog",
+		description: "Read this first. Lists every Silk resource grouped by tier with a 'load when' hint. Fetch a doc with resources/read <uri>; search by intent with silk_docs_search.",
+		mimeType: "text/markdown"
+	}, async (uri) => ({ contents: [{
+		uri: uri.href,
+		mimeType: "text/markdown",
+		text: renderCatalogMarkdown(manifest)
+	}] }));
+	const byUri = new Map(manifest.entries.map((e) => [e.uri, e]));
+	const readBody = (uri, relPath) => bodies ? bodies[uri] ?? "" : readDocBody(contentRoot, relPath);
+	server.registerResource("silk_doc", new ResourceTemplate("silk://{+path}", { list: async () => ({ resources: manifest.entries.filter((e) => e.status !== "deprecated").map((e) => ({
+		name: resourceName(e),
+		uri: e.uri,
+		title: e.title,
+		description: e.summary,
+		mimeType: "text/markdown",
+		annotations: toSdkAnnotations(e)
+	})) }) }), {
+		title: "Silk documentation resource",
+		mimeType: "text/markdown"
+	}, async (uri, variables) => {
+		const relPath = String(variables.path ?? "");
+		const entry = byUri.get(uri.href);
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "text/markdown",
+			text: readBody(uri.href, relPath),
+			...entry ? { annotations: toSdkAnnotations(entry) } : {}
+		}] };
+	});
+}
+
+//#endregion
+export { registerAllResources };

package/resources/load.js

@@ -0,0 +1,38 @@
+import { resolveResourcePath } from "./paths.js";
+import { Manifest } from "./schema.js";
+import { Schema } from "effect";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/resources/load.ts
+/**
+* Resolve the content root across source/built layouts and load the manifest
+* + a doc body by relative path.
+*
+* @packageDocumentation
+*/
+/**
+* Locate the directory holding `manifest.json` + the content markdown. The
+* built bundle copies `public/` next to the emitted chunk (`<pkg>/public/content`);
+* the source layout keeps it under the package root (`packages/mcp/public/content`).
+* Probe both and fail loudly if neither has a manifest, so a broken build surfaces a
+* clear path list instead of an opaque ENOENT later in {@link loadManifest}.
+*/
+function resolveContentRoot() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const candidates = [join(here, "..", "public", "content"), join(here, "..", "..", "public", "content")];
+	for (const candidate of candidates) if (existsSync(join(candidate, "manifest.json"))) return candidate;
+	throw new Error(`[savvy-mcp] cannot locate public/content with a manifest.json (tried: ${candidates.join(", ")})`);
+}
+function loadManifest(contentRoot) {
+	const raw = JSON.parse(readFileSync(join(contentRoot, "manifest.json"), "utf8"));
+	return Schema.decodeUnknownSync(Manifest)(raw);
+}
+/** Read a doc body markdown by its relative path (the `{+path}` template var). */
+function readDocBody(contentRoot, relPath) {
+	return readFileSync(resolveResourcePath(contentRoot, relPath), "utf8");
+}
+
+//#endregion
+export { loadManifest, readDocBody, resolveContentRoot };

package/resources/paths.js

@@ -0,0 +1,23 @@
+import { isAbsolute, normalize, resolve, sep } from "node:path";
+
+//#region src/resources/paths.ts
+/**
+* Resolve a relative content path against the content root, appending `.md`
+* (or `index.md` for a trailing slash) and rejecting traversal. Operates on
+* the manifest-resolved relative path, never on URL components.
+*
+* @packageDocumentation
+*/
+function resolveResourcePath(root, relativePath) {
+	if (relativePath.includes("\0")) throw new Error("path contains null byte");
+	if (isAbsolute(relativePath)) throw new Error("absolute path not allowed");
+	const stripped = relativePath.replace(/^\/+/, "");
+	const withIndex = stripped === "" || stripped.endsWith("/") ? `${stripped}index` : stripped;
+	const resolved = resolve(root, normalize(withIndex.endsWith(".md") ? withIndex : `${withIndex}.md`));
+	const rootWithSep = root.endsWith(sep) ? root : `${root}${sep}`;
+	if (!resolved.startsWith(rootWithSep) && resolved !== root) throw new Error("path escapes content root");
+	return resolved;
+}
+
+//#endregion
+export { resolveResourcePath };

package/resources/query-log.js

@@ -0,0 +1,20 @@
+//#region src/resources/query-log.ts
+/** Build the structured stderr line for one search (pure; no I/O). */
+function formatQueryLogLine(query, results) {
+	const top = results.slice(0, 3);
+	const belowThreshold = results.length === 0 || results.every((r) => r.confidenceLabel === "low");
+	const payload = {
+		query,
+		topResults: top.map((r) => r.uri),
+		topConfidence: results[0]?.confidence ?? 0,
+		belowThreshold
+	};
+	return `[savvy-mcp] docs-search ${JSON.stringify(payload)}`;
+}
+/** Write a query log line to stderr. */
+const stderrQueryLogger = (line) => {
+	process.stderr.write(`${line}\n`);
+};
+
+//#endregion
+export { formatQueryLogLine, stderrQueryLogger };

package/resources/schema.js

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+
+//#region src/resources/schema.ts
+/**
+* Front-matter and manifest schemas for the Silk resource corpus.
+*
+* @packageDocumentation
+*/
+/** `id` = the stable URI suffix: tier-prefixed, slash-separated slug segments. */
+const ID_PATTERN = /^(standards|packages|guides)\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*\/?$/;
+const Tier = Schema.Literal("standards", "packages", "guides");
+const Audience = Schema.Array(Schema.Literal("user", "assistant"));
+const Source = Schema.Literal("hand", "generated");
+const Status = Schema.Literal("draft", "stable", "deprecated");
+/** YAML front-matter on every content markdown file. */
+const DocFrontMatter = Schema.Struct({
+	id: Schema.String.pipe(Schema.pattern(ID_PATTERN)),
+	title: Schema.NonEmptyString,
+	summary: Schema.NonEmptyString,
+	tier: Tier,
+	source: Source,
+	status: Schema.optionalWith(Status, { default: () => "stable" }),
+	supersededBy: Schema.optional(Schema.String),
+	tags: Schema.Array(Schema.NonEmptyString),
+	audience: Schema.optionalWith(Audience, { default: () => ["assistant"] }),
+	priority: Schema.optionalWith(Schema.Number.pipe(Schema.between(0, 1)), { default: () => .5 }),
+	related: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] })
+});
+/** A manifest entry = decoded front-matter + the derived uri + lastModified. */
+const ManifestEntry = Schema.Struct({
+	...DocFrontMatter.fields,
+	uri: Schema.String,
+	lastModified: Schema.optional(Schema.String)
+});
+const Manifest = Schema.Struct({ entries: Schema.Array(ManifestEntry) });
+const decodeDocFrontMatter = Schema.decodeUnknown(DocFrontMatter);
+const decodeManifest = Schema.decodeUnknown(Manifest);
+
+//#endregion
+export { Manifest };

package/runtime.js

@@ -0,0 +1,40 @@
+import { ChangesetConfigReaderLive, Changesets, SilkWorkspaceAnalyzerLive, TagStrategyLive, ToolDiscoveryLive, Turbo, VersioningStrategyLive } from "@savvy-web/silk-effects";
+import { Layer } from "effect";
+import { WorkspaceRootLive, WorkspacesLive } from "workspaces-effect";
+
+//#region src/runtime.ts
+/**
+* Composes the long-lived Effect runtime layer for the MCP server.
+*
+* `SilkRuntimeLive` provides {@link SilkWorkspaceAnalyzer} and {@link WorkspaceRoot}.
+* `WorkspaceRoot` lets the server resolve the workspace root by walking up from
+* its launch directory. The layer still requires `FileSystem` + `Path`; the host
+* (bin.ts) supplies them via `NodeContext.layer`.
+*
+* @packageDocumentation
+*/
+/**
+* The silk-effects dependency set fed to {@link SilkWorkspaceAnalyzerLive}.
+*
+* `WorkspacesLive` supplies the workspace trio plus `DependencyGraph` and
+* `TopologicalSorter` (all required by the analyzer). `VersioningStrategyLive`
+* is provided its own `ChangesetConfigReader` because `Layer.mergeAll` does not
+* cross-feed sibling layers.
+*/
+const DepsLive = Layer.mergeAll(WorkspacesLive, ChangesetConfigReaderLive, TagStrategyLive, VersioningStrategyLive.pipe(Layer.provide(ChangesetConfigReaderLive)));
+const InspectorAndAnalyzerLive = Changesets.BranchAnalyzerLive.pipe(Layer.provideMerge(Changesets.ConfigInspectorLive));
+/**
+* The MCP runtime layer. Provides `SilkWorkspaceAnalyzer`, `WorkspaceRoot`,
+* `Turbo.TurboInspector`, `Changesets.BranchAnalyzer`, and
+* `Changesets.ConfigInspector`; 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));
+
+//#endregion
+export { SilkRuntimeLive };

package/schema/effect-to-zod.js

@@ -0,0 +1,52 @@
+import { JSONSchema } from "effect";
+import { z } from "zod";
+
+//#region src/schema/effect-to-zod.ts
+/**
+* Convert an Effect `Schema.Schema<A, I, never>` to a zod schema:
+* `JSONSchema.make`, then inline every `#/$defs/*` `$ref`, then `z.fromJSONSchema`.
+*
+* @remarks
+* - Effect-only refinements (custom predicates, brands) erase during the
+*   round-trip; declare zod directly if boundary enforcement matters.
+* - The source schema must not use `Schema.suspend` (recursive `$ref`s would
+*   make `inlineAllRefs` non-terminating). MCP tool output schemas in this
+*   package are non-recursive projections by construction.
+* - The MCP SDK normalises `outputSchema` to an object; non-object results
+*   (e.g. a bare union) are wrapped in a permissive object so the SDK accepts
+*   them.
+*/
+const effectToZodSchema = (schema) => {
+	const inlined = inlineAllRefs(JSONSchema.make(schema));
+	const zodSchema = z.fromJSONSchema(inlined);
+	if (isObjectLike(zodSchema)) return zodSchema;
+	return z.object({}).catchall(z.unknown());
+};
+const isObjectLike = (schema) => schema instanceof z.ZodObject;
+const REF_PREFIX = "#/$defs/";
+/**
+* Replace every `$ref: "#/$defs/X"` node with the contents of `$defs.X`,
+* recursively, and drop the `$defs` table. Assumes acyclic refs.
+*/
+const inlineAllRefs = (root) => {
+	const defs = root.$defs ?? {};
+	const visit = (value) => {
+		if (Array.isArray(value)) return value.map(visit);
+		if (value === null || typeof value !== "object") return value;
+		const obj = value;
+		if (typeof obj.$ref === "string" && obj.$ref.startsWith(REF_PREFIX)) {
+			const target = defs[obj.$ref.slice(8)];
+			if (target !== void 0) return visit(target);
+		}
+		const out = {};
+		for (const [k, v] of Object.entries(obj)) {
+			if (k === "$defs") continue;
+			out[k] = visit(v);
+		}
+		return out;
+	};
+	return visit(root);
+};
+
+//#endregion
+export { effectToZodSchema };

package/server.js

@@ -0,0 +1,124 @@
+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 { ChangesetInspectAsMarkdown, ChangesetInspectResult, changesetInspect } from "./tools/changeset-inspect.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";
+import { Schema } from "effect";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+//#region src/server.ts
+/**
+* Constructs the MCP server, registers tools and resources, and connects the
+* stdio transport.
+*
+* @packageDocumentation
+*/
+/** Wrap a markdown string + structured object in the dual-channel tool result. */
+const structuredResult = (text, structured) => ({
+	content: [{
+		type: "text",
+		text
+	}],
+	structuredContent: structured
+});
+/** Build the MCP server for the given context, registering tools + resources. */
+function buildServer(ctx) {
+	const server = new McpServer({
+		name: "savvy-mcp",
+		version: CURRENT_MCP_VERSION
+	});
+	server.registerTool("workspace_info", {
+		description: "Use when you need the Silk workspace layout: runtime, package manager, and a per-workspace summary (publishability, versioning, tag/release state). Prefer this over running shell commands to inspect the workspace. Returns markdown in content[] and a typed object in structuredContent.",
+		inputSchema: { cwd: z.optional(z.string()).describe("Workspace root to analyze. Defaults to the server's project dir.") },
+		outputSchema: effectToZodSchema(WorkspaceInfoResult)
+	}, async (args) => {
+		const root = args.cwd ?? ctx.cwd;
+		const data = await ctx.runtime.runPromise(workspaceInfo(root));
+		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: {
+			mode: z.enum([
+				"cache",
+				"graph",
+				"affected"
+			]).describe("Which inspection to run."),
+			task: z.optional(z.string()).describe("Task name (defaults to build:dev for cache/graph)."),
+			base: z.optional(z.string()).describe("Base git ref for affected mode."),
+			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
+		},
+		outputSchema: effectToZodSchema(TurboInspectResult),
+		annotations: { readOnlyHint: true }
+	}, async (args) => {
+		const data = await ctx.runtime.runPromise(turboInspect(args, ctx.cwd));
+		return structuredResult(Schema.decodeSync(TurboInspectAsMarkdown)(data), 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). Prefer this over shelling out to the savvy CLI.",
+		inputSchema: {
+			mode: z.enum(["branch", "config"]).describe("Which inspection to run."),
+			base: z.optional(z.string()).describe("Override the base branch (branch mode only)."),
+			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
+		},
+		outputSchema: effectToZodSchema(ChangesetInspectResult),
+		annotations: { readOnlyHint: true }
+	}, async (args) => {
+		const data = await ctx.runtime.runPromise(changesetInspect(args, ctx.cwd));
+		return structuredResult(Schema.decodeSync(ChangesetInspectAsMarkdown)(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: {
+			paths: z.optional(z.array(z.string())).describe("Paths to check. Defaults to the whole workspace."),
+			mode: z.optional(z.enum(["check", "lint"])).describe("check = lint+format+imports (default); lint = lint only."),
+			write: z.optional(z.boolean()).describe("Apply safe fixes (--write)."),
+			unsafe: z.optional(z.boolean()).describe("Apply unsafe fixes (--write --unsafe); implies write."),
+			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
+		},
+		outputSchema: effectToZodSchema(BiomeCheckResult)
+	}, async (args) => {
+		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. */
+async function startMcpServer(ctx) {
+	const server = buildServer(ctx);
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+
+//#endregion
+export { startMcpServer };

package/tools/biome-check.js

@@ -0,0 +1,188 @@
+import { Lint } from "@savvy-web/silk-effects";
+import { ParseResult, Schema } from "effect";
+import { realpathSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
+import { spawnSync } from "node:child_process";
+
+//#region src/tools/biome-check.ts
+/**
+* The `biome_check` MCP tool: a thin proxy that runs Biome over a path with the
+* gitlab reporter, parses it into a typed result, and can apply fixes. Unlike the
+* other savvy-mcp tools this one MUTATES the working tree when `write`/`unsafe`
+* is set — the first intentional exception to the read-only convention.
+*
+* @packageDocumentation
+*/
+/** Normalized diagnostic severity. */
+const BiomeSeverity = Schema.Literal("error", "warning", "info");
+/** A single normalized Biome diagnostic. */
+const BiomeDiagnostic = Schema.Struct({
+	file: Schema.String,
+	line: Schema.Number,
+	severity: BiomeSeverity,
+	rule: Schema.String,
+	message: Schema.String
+}).annotations({ identifier: "BiomeDiagnostic" });
+/** The `biome_check` tool result. */
+const BiomeCheckResult = Schema.Struct({
+	summary: Schema.Struct({
+		errors: Schema.Number,
+		warnings: Schema.Number
+	}),
+	diagnostics: Schema.Array(BiomeDiagnostic),
+	wrote: Schema.Boolean,
+	guidance: Schema.String
+}).annotations({
+	identifier: "BiomeCheckResult",
+	title: "biome_check result",
+	description: "Structured Biome diagnostics, with a flag for whether a --write pass ran."
+});
+/** Guardrail shown to the agent so it fixes code rather than silencing rules. */
+const GUIDANCE = "Fix the actual code. Do NOT disable rules or add config overrides to silence these.";
+/** Shape of a single diagnostic in Biome's `--reporter=gitlab` output. */
+const GitlabDiagnostic = Schema.Struct({
+	description: Schema.String,
+	check_name: Schema.String,
+	severity: Schema.Literal("info", "minor", "major", "critical", "blocker"),
+	location: Schema.Struct({
+		path: Schema.String,
+		lines: Schema.Struct({ begin: Schema.Number })
+	})
+});
+const GitlabArray = Schema.Array(GitlabDiagnostic);
+const decodeGitlab = Schema.decodeUnknownSync(GitlabArray);
+/** Map a gitlab severity onto our three-level scale. */
+const mapSeverity = (s) => s === "info" ? "info" : s === "minor" ? "warning" : "error";
+/**
+* Parse Biome `--reporter=gitlab` stdout into normalized diagnostics. Returns []
+* for empty, non-JSON, or shape-mismatched input (never throws).
+*/
+const parseBiomeGitlab = (stdout) => {
+	const trimmed = stdout.trim();
+	if (!trimmed) return [];
+	let raw;
+	try {
+		raw = JSON.parse(trimmed);
+	} catch {
+		return [];
+	}
+	let decoded;
+	try {
+		decoded = decodeGitlab(raw);
+	} catch {
+		return [];
+	}
+	return decoded.map((d) => ({
+		file: d.location.path,
+		line: d.location.lines.begin,
+		severity: mapSeverity(d.severity),
+		rule: d.check_name,
+		message: d.description
+	}));
+};
+/** Assemble the structured result from normalized diagnostics + the write flag. */
+const buildBiomeResult = (params) => {
+	return {
+		summary: {
+			errors: params.diagnostics.filter((d) => d.severity === "error").length,
+			warnings: params.diagnostics.filter((d) => d.severity === "warning").length
+		},
+		diagnostics: [...params.diagnostics],
+		wrote: params.wrote,
+		guidance: 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 lines = [`# biome — ${data.summary.errors} error(s), ${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) lines.push(`- \`${d.file}:${d.line}\` **${d.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 = Schema.transformOrFail(BiomeCheckResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "BiomeCheckAsMarkdown is one-way: markdown cannot be parsed back."))
+});
+/**
+* Run Biome and return structured diagnostics. When `write`/`unsafe` is set,
+* runs a fix pass first, then a read-only gitlab pass to report what remains.
+*
+* @remarks Resolves the Biome binary via {@link Lint.Biome.findBiome} (global
+* first, then the project's package manager). Throws if Biome is unavailable or
+* exits with status > 1 (Biome itself failed, vs. status 1 = lint issues found).
+*/
+const runBiomeCheck = async (args, fallbackCwd) => {
+	const mode = args.mode ?? "check";
+	const canonicalize = (p) => {
+		try {
+			return realpathSync(p);
+		} catch {
+			return resolve(p);
+		}
+	};
+	const root = canonicalize(fallbackCwd);
+	const within = (abs) => abs === root || abs.startsWith(`${root}${sep}`);
+	const cwd = canonicalize(args.cwd ?? fallbackCwd);
+	if (!within(cwd)) throw new Error(`cwd escapes the workspace root: ${args.cwd}`);
+	const paths = (args.paths && args.paths.length > 0 ? args.paths : ["."]).map((p) => {
+		const lexical = resolve(cwd, p);
+		if (!within(canonicalize(lexical))) throw new Error(`path escapes the workspace root: ${p}`);
+		return relative(cwd, lexical) || ".";
+	});
+	const doWrite = Boolean(args.write || args.unsafe);
+	const biomeCmd = Lint.Biome.findBiome();
+	if (!biomeCmd) throw new Error("Biome not found. Install @biomejs/biome globally (recommended) or as a devDependency.");
+	const parts = biomeCmd.split(" ");
+	const bin = parts[0];
+	const prefix = parts.slice(1);
+	const maxBuffer = 64 * 1024 * 1024;
+	const timeout = 12e4;
+	const killSignal = "SIGKILL";
+	let wrote = false;
+	if (doWrite) {
+		const fix = spawnSync(bin, [
+			...prefix,
+			mode,
+			"--write",
+			...args.unsafe ? ["--unsafe"] : [],
+			"--no-errors-on-unmatched",
+			...paths
+		], {
+			cwd,
+			encoding: "utf8",
+			maxBuffer,
+			timeout,
+			killSignal
+		});
+		if (fix.error) throw fix.error;
+		if ((fix.status ?? 0) > 1) throw new Error(`Biome --write failed (exit ${fix.status}): ${(fix.stderr ?? "").trim() || "unknown error"}`);
+		wrote = true;
+	}
+	const read = spawnSync(bin, [
+		...prefix,
+		mode,
+		"--reporter=gitlab",
+		"--error-on-warnings",
+		"--no-errors-on-unmatched",
+		...paths
+	], {
+		cwd,
+		encoding: "utf8",
+		maxBuffer,
+		timeout,
+		killSignal
+	});
+	if (read.error) throw read.error;
+	if ((read.status ?? 0) > 1) throw new Error(`Biome failed (exit ${read.status}): ${(read.stderr ?? "").trim() || "unknown error"}`);
+	return buildBiomeResult({
+		diagnostics: parseBiomeGitlab(read.stdout ?? ""),
+		wrote
+	});
+};
+
+//#endregion
+export { BiomeCheckAsMarkdown, BiomeCheckResult, runBiomeCheck };

package/tools/changeset-inspect.js

@@ -0,0 +1,108 @@
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect, ParseResult, Schema } from "effect";
+import { WorkspaceRoot } from "workspaces-effect";
+
+//#region src/tools/changeset-inspect.ts
+/**
+* The `changeset_inspect` MCP tool: a discriminated-union result keyed by `mode`
+* (branch | config), each variant embedding the corresponding resolved-output
+* schema from silk-effects' Changesets namespace, plus a one-way markdown
+* transform. Read-only.
+*
+* @packageDocumentation
+*/
+/** Branch-analysis variant. */
+const ChangesetBranchResult = Schema.Struct({
+	mode: Schema.Literal("branch"),
+	result: Changesets.BranchAnalysisSchema
+}).annotations({ identifier: "ChangesetBranchResult" });
+/** Config-inspection variant. */
+const ChangesetConfigResult = Schema.Struct({
+	mode: Schema.Literal("config"),
+	result: Changesets.InspectedConfigSchema
+}).annotations({ identifier: "ChangesetConfigResult" });
+/** The `changeset_inspect` tool result — a discriminated union keyed by `mode`. */
+const ChangesetInspectResult = Schema.Union(ChangesetBranchResult, ChangesetConfigResult).annotations({
+	identifier: "ChangesetInspectResult",
+	title: "changeset_inspect result",
+	description: "Read-only changeset analysis grouped by mode (branch | config)."
+});
+/**
+* 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) : "<unmapped>";
+				lines.push(`- ${mdInline(f.status)}  ${mdInline(f.path)}  ->  ${owner}`);
+			}
+			if (r.unmappedFiles.length > 0) {
+				lines.push(``, `## Unmapped (ask the user)`);
+				for (const p of r.unmappedFiles) lines.push(`- ${mdInline(p)}`);
+			}
+			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(`### ${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");
+		}
+	}
+};
+/** One-way transform: result to markdown. Encoding back is forbidden. */
+const ChangesetInspectAsMarkdown = Schema.transformOrFail(ChangesetInspectResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "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`.
+*/
+const changesetInspect = (args, fallbackCwd) => Effect.gen(function* () {
+	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
+	switch (args.mode) {
+		case "branch": return {
+			mode: "branch",
+			result: yield* (yield* Changesets.BranchAnalyzer).analyzeBranch(root, args.base ? { baseBranch: args.base } : void 0)
+		};
+		case "config": return {
+			mode: "config",
+			result: yield* (yield* Changesets.ConfigInspector).inspect(root)
+		};
+	}
+});
+
+//#endregion
+export { ChangesetInspectAsMarkdown, ChangesetInspectResult, changesetInspect };

package/tools/docs-search.js

@@ -0,0 +1,59 @@
+import { formatQueryLogLine } from "../resources/query-log.js";
+import { ParseResult, Schema } from "effect";
+
+//#region src/tools/docs-search.ts
+/**
+* The `silk_docs_search` MCP tool: a read-only Fuse-backed search over the
+* resource corpus. Takes a plain keyword/phrase query (no operator DSL),
+* returns ranked results with normalized higher-is-better confidence, and
+* never returns empty.
+*
+* @packageDocumentation
+*/
+const DocsSearchHit = Schema.Struct({
+	uri: Schema.String,
+	title: Schema.String,
+	summary: Schema.String,
+	tags: Schema.Array(Schema.String),
+	tier: Schema.Literal("standards", "packages", "guides"),
+	confidence: Schema.Number,
+	confidenceLabel: Schema.Literal("high", "medium", "low"),
+	matchedOn: Schema.Array(Schema.String),
+	related: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] })
+}).annotations({ identifier: "DocsSearchHit" });
+const DocsSearchResult = Schema.Struct({
+	query: Schema.String,
+	results: Schema.Array(DocsSearchHit)
+}).annotations({
+	identifier: "DocsSearchResult",
+	title: "silk_docs_search result",
+	description: "Ranked Silk documentation matches. Fetch a hit with resources/read <uri>."
+});
+const formatDocsSearchMarkdown = (data) => {
+	const lines = [`# silk_docs_search: ${data.query}`, ""];
+	if (data.results.length === 0) {
+		lines.push("No results. Read `silk://catalog` and select a doc by reasoning.");
+		return lines.join("\n");
+	}
+	if (data.results.every((r) => r.confidenceLabel === "low")) lines.push("_No high-confidence match — read `silk://catalog` and pick by reasoning._", "");
+	for (const r of data.results) lines.push(`- \`${r.uri}\` (${r.confidenceLabel}) — ${r.title}. ${r.summary}`);
+	lines.push("", "Fetch any hit with `resources/read <uri>`.");
+	return lines.join("\n");
+};
+const DocsSearchResultAsMarkdown = Schema.transformOrFail(DocsSearchResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatDocsSearchMarkdown(data)),
+	encode: (text, _opts, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "DocsSearchResultAsMarkdown is one-way."))
+});
+/** Run a search against the in-memory index (synchronous; no Effect runtime). */
+const runDocsSearch = (index, query, opts, logger) => {
+	const results = index.search(query, opts);
+	if (logger) logger(formatQueryLogLine(query, results));
+	return {
+		query,
+		results
+	};
+};
+
+//#endregion
+export { DocsSearchResult, DocsSearchResultAsMarkdown, runDocsSearch };

package/tools/turbo-inspect.js

@@ -0,0 +1,113 @@
+import { Turbo } from "@savvy-web/silk-effects";
+import { Effect, ParseResult, Schema } from "effect";
+import { WorkspaceRoot } from "workspaces-effect";
+
+//#region src/tools/turbo-inspect.ts
+/**
+* The `turbo_inspect` MCP tool: a discriminated-union result schema keyed by
+* `mode` (cache | graph | affected), each variant embedding the corresponding
+* `Turbo` result schema from silk-effects, plus a one-way markdown transform.
+*
+* @packageDocumentation
+*/
+/** Cache-diagnosis variant of the `turbo_inspect` result. */
+const TurboCacheResult = Schema.Struct({
+	mode: Schema.Literal("cache"),
+	result: Turbo.CacheDiagnosis
+}).annotations({ identifier: "TurboCacheResult" });
+/** Task-graph variant of the `turbo_inspect` result. */
+const TurboGraphResult = Schema.Struct({
+	mode: Schema.Literal("graph"),
+	result: Turbo.TaskGraphResult
+}).annotations({ identifier: "TurboGraphResult" });
+/** Affected-packages variant of the `turbo_inspect` result. */
+const TurboAffectedResult = Schema.Struct({
+	mode: Schema.Literal("affected"),
+	result: Turbo.AffectedResult
+}).annotations({ identifier: "TurboAffectedResult" });
+/** The `turbo_inspect` tool result — a discriminated union keyed by `mode`. */
+const TurboInspectResult = Schema.Union(TurboCacheResult, TurboGraphResult, TurboAffectedResult).annotations({
+	identifier: "TurboInspectResult",
+	title: "turbo_inspect result",
+	description: "Read-only Turborepo inspection grouped by mode (cache | graph | affected)."
+});
+/** Render the structured result as a markdown transcript. */
+const renderMarkdown = (data) => {
+	switch (data.mode) {
+		case "cache": {
+			const r = data.result;
+			const lines = [
+				`# turbo cache — ${r.task}`,
+				``,
+				`**${r.hits}/${r.totalTasks} cached**, ${r.misses} miss(es).`,
+				``,
+				`## Global hash`,
+				`- rootKey: \`${r.global.rootKey}\``,
+				`- global files: ${r.global.globalFileCount}`,
+				`- external deps hash: \`${r.global.externalDependenciesHash}\``,
+				`- internal deps hash: \`${r.global.internalDependenciesHash}\``,
+				`- global env: ${r.global.globalEnvVars.join(", ") || "(none)"}`
+			];
+			if (r.explanations.length > 0) {
+				lines.push(``, `## Misses`);
+				for (const m of r.explanations) lines.push(`### ${m.package} (\`${m.taskId}\`)`, `- hash: \`${m.hash}\``, `- input files: ${m.inputFileCount}`, `- hashed env: ${m.hashedEnvVars.join(", ") || "(none)"}`, `- external deps hash: \`${m.externalDependenciesHash}\``, `- depends on: ${m.dependsOn.join(", ") || "(none)"}`);
+			}
+			return lines.join("\n");
+		}
+		case "graph": {
+			const r = data.result;
+			return [
+				`# turbo task graph${r.task ? ` — ${r.task}` : ""}`,
+				``,
+				`${r.nodeCount} task node(s).`,
+				``,
+				`## Critical path`,
+				r.criticalPath.map((id, i) => `${i + 1}. \`${id}\``).join("\n") || "(empty)"
+			].join("\n");
+		}
+		case "affected": {
+			const r = data.result;
+			return [
+				`# turbo affected — base ${r.base}`,
+				``,
+				`## Changed packages`,
+				r.packages.map((p) => `- ${p}`).join("\n") || "(none)",
+				``,
+				`## Dependents`,
+				r.dependents.map((p) => `- ${p}`).join("\n") || "(none)"
+			].join("\n");
+		}
+	}
+};
+/** One-way transform: result to markdown. Encoding back is forbidden. */
+const TurboInspectAsMarkdown = Schema.transformOrFail(TurboInspectResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TurboInspectAsMarkdown is one-way: markdown cannot be parsed back."))
+});
+/**
+* Effect handler: resolve the workspace root by walking up from the requested
+* directory, then dispatch to the matching {@link Turbo.TurboInspector} method
+* keyed by `mode`. Mirrors `workspaceInfo`'s `WorkspaceRoot.find` resolution.
+*/
+const turboInspect = (args, fallbackCwd) => Effect.gen(function* () {
+	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
+	const inspector = yield* Turbo.TurboInspector;
+	switch (args.mode) {
+		case "cache": return {
+			mode: "cache",
+			result: yield* inspector.diagnoseCache(args.task ?? "build:dev", root)
+		};
+		case "graph": return {
+			mode: "graph",
+			result: yield* inspector.taskGraph(root, args.task)
+		};
+		case "affected": return {
+			mode: "affected",
+			result: yield* inspector.affected(root, args.base)
+		};
+	}
+});
+
+//#endregion
+export { TurboInspectAsMarkdown, TurboInspectResult, turboInspect };

package/tools/workspace-info.js

@@ -0,0 +1,92 @@
+import { SilkWorkspaceAnalyzer } from "@savvy-web/silk-effects";
+import { Effect, ParseResult, Schema } from "effect";
+import { WorkspaceRoot } from "workspaces-effect";
+
+//#region src/tools/workspace-info.ts
+/** A flattened, non-recursive summary of one analyzed workspace. */
+const WorkspaceSummary = Schema.Struct({
+	name: Schema.String,
+	version: Schema.String,
+	path: Schema.String,
+	root: Schema.Boolean,
+	publishable: Schema.Boolean,
+	targets: Schema.Array(Schema.String).annotations({ description: "Publish registry URLs." }),
+	versioned: Schema.Boolean,
+	tagged: Schema.Boolean,
+	released: Schema.Boolean,
+	linked: Schema.Array(Schema.String).annotations({ description: "Names of linked workspaces." }),
+	fixed: Schema.Array(Schema.String).annotations({ description: "Names of fixed-group siblings." })
+}).annotations({ identifier: "WorkspaceSummary" });
+/** The `workspace_info` tool result — a projection of `WorkspaceAnalysis`. */
+const WorkspaceInfoResult = Schema.Struct({
+	root: Schema.String,
+	runtime: Schema.Literal("node", "bun"),
+	packageManager: Schema.Struct({
+		type: Schema.Literal("npm", "pnpm", "yarn", "bun"),
+		version: Schema.optional(Schema.String)
+	}),
+	workspaceCount: Schema.Number,
+	workspaces: Schema.Array(WorkspaceSummary)
+}).annotations({
+	identifier: "WorkspaceInfoResult",
+	title: "workspace_info result",
+	description: "Structured snapshot of the Silk workspace: runtime, package manager, and a per-workspace summary (publishability, versioning, tag/release state, linked/fixed relations)."
+});
+const toSummary = (w) => ({
+	name: w.name,
+	version: w.version.current,
+	path: w.path,
+	root: w.root,
+	publishable: w.publishable,
+	targets: w.targets.map((t) => t.registry),
+	versioned: w.versioned,
+	tagged: w.tagged,
+	released: w.released,
+	linked: w.linked.map((l) => l.name),
+	fixed: w.fixed.map((f) => f.name)
+});
+/** Project a full `WorkspaceAnalysis` to the flat tool result. */
+const toWorkspaceInfoResult = (analysis) => ({
+	root: analysis.root,
+	runtime: analysis.runtime,
+	packageManager: {
+		type: analysis.packageManager.type,
+		...analysis.packageManager.version !== void 0 ? { version: analysis.packageManager.version } : {}
+	},
+	workspaceCount: analysis.workspaces.length,
+	workspaces: analysis.workspaces.map(toSummary)
+});
+/** Render the structured result as a markdown transcript. */
+const formatWorkspaceInfoMarkdown = (data) => {
+	const pm = data.packageManager.version ? `${data.packageManager.type}@${data.packageManager.version}` : data.packageManager.type;
+	const lines = [
+		`# Workspace: ${data.root}`,
+		"",
+		`- runtime: ${data.runtime}`,
+		`- package manager: ${pm}`,
+		`- workspaces: ${data.workspaceCount}`,
+		"",
+		"| name | version | publishable | versioned | tagged | released |",
+		"| --- | --- | --- | --- | --- | --- |"
+	];
+	for (const w of data.workspaces) lines.push(`| ${w.name} | ${w.version} | ${w.publishable} | ${w.versioned} | ${w.tagged} | ${w.released} |`);
+	return lines.join("\n");
+};
+/** One-way transform: result to markdown. Encoding back is forbidden. */
+const WorkspaceInfoAsMarkdown = Schema.transformOrFail(WorkspaceInfoResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatWorkspaceInfoMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "WorkspaceInfoAsMarkdown is one-way: markdown cannot be parsed back."))
+});
+/**
+* Effect handler: resolve the workspace root by walking up from `base`, analyze
+* that root, and project to the tool result. Fails with `WorkspaceRootNotFoundError`
+* when `base` is not inside a workspace.
+*/
+const workspaceInfo = (base) => Effect.gen(function* () {
+	const root = yield* (yield* WorkspaceRoot).find(base);
+	return toWorkspaceInfoResult(yield* (yield* SilkWorkspaceAnalyzer).analyze(root));
+});
+
+//#endregion
+export { WorkspaceInfoAsMarkdown, WorkspaceInfoResult, workspaceInfo };

package/version.js

@@ -0,0 +1,12 @@
+//#region src/version.ts
+/**
+* The package version, replaced at build time. `0.0.0` in dev/test indicates
+* an unbuilt source run. Kept in its own module so both `server.ts` and the
+* `index.ts` barrel can import it without forming an import cycle.
+*
+* @packageDocumentation
+*/
+const CURRENT_MCP_VERSION = "0.0.0";
+
+//#endregion
+export { CURRENT_MCP_VERSION };