@savvy-web/mcp 1.8.1 → 2.0.0

package/bin/savvy-mcp.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { SilkRuntimeLive } from "../runtime.js";
+import { makeSilkRuntimeLayer } from "../runtime.js";
 import { startMcpServer } from "../server.js";
 import { Layer, ManagedRuntime } from "effect";
-import { NodeContext } from "@effect/platform-node";
+import { NodeServices } from "@effect/platform-node";
 
 //#region src/bin.ts
 /**
 * Binary entrypoint for the `savvy-mcp` server.
 *
-* Resolves the project working directory, builds the long-lived runtime, and
-* starts the MCP server over stdio.
+* Resolves the project working directory, builds the long-lived runtime
+* (root-bound to that directory), and starts the MCP server over stdio.
 *
 * @internal
 */
@@ -20,7 +20,7 @@ function resolveProjectDir() {
 }
 async function main() {
 	const cwd = resolveProjectDir();
-	const appLayer = SilkRuntimeLive.pipe(Layer.provide(NodeContext.layer));
+	const appLayer = makeSilkRuntimeLayer(cwd).pipe(Layer.provide(NodeServices.layer));
 	const ctx = {
 		runtime: ManagedRuntime.make(appLayer),
 		cwd

package/index.d.ts

@@ -1,29 +1,41 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets, Repos, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
-import { Layer, ManagedRuntime } from "effect";
-import { WorkspaceDiscoveryError, WorkspaceRoot } from "workspaces-effect";
+import { FileSystem, Layer, ManagedRuntime, Path } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
 import "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/context.d.ts
+/** Every service the MCP runtime provides to the tool handlers. */
+type McpServices = SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner | Changesets.DepsRegen | Repos.ReposManager | Repos.ReposConfigStore;
 /** 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 | Changesets.DepsRegen | Repos.ReposManager | Repos.ReposConfigStore, WorkspaceDiscoveryError>;
+  readonly runtime: ManagedRuntime.ManagedRuntime<McpServices, never>;
   readonly cwd: string;
 }
 //#endregion
 //#region src/runtime.d.ts
 /**
- * The MCP runtime layer. Provides `SilkWorkspaceAnalyzer`, `WorkspaceRoot`,
- * `Turbo.TurboInspector`, `Changesets.BranchAnalyzer`,
- * `Changesets.ConfigInspector`, `Changesets.ReleasePlanner`,
- * `Changesets.DepsRegen`, `Repos.ReposManager`, and `Repos.ReposConfigStore`;
- * requires `CommandExecutor` + `FileSystem` + `Path` from the host's platform
- * layer (`NodeContext.layer` in bin.ts).
+ * Build the MCP runtime layer for a workspace root. Provides
+ * `SilkWorkspaceAnalyzer`, `WorkspaceRoot`, `Turbo.TurboInspector`,
+ * `Changesets.BranchAnalyzer`, `Changesets.ConfigInspector`,
+ * `Changesets.ReleasePlanner`, `Changesets.DepsRegen`, `Repos.ReposManager`,
+ * and `Repos.ReposConfigStore`; requires `ChildProcessSpawner` + `FileSystem`
+ * + `Path` from the host's platform layer (`NodeServices.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.
+ * @remarks
+ * The kit graph (`Workspaces.layerWithGit`) 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
+ * the whole runtime a SINGLE `ConfigInspector` (the MCP server holds one for
+ * its whole process lifetime, #229 — `changeset_inspect` refreshes it before
+ * every call, and `BranchAnalyzer`, `ReleasePlanner`, and `DepsRegen` all read
+ * through that shared instance). `DepsRegen` is gated by silk's adaptive
+ * publishability detector — provided closer than the kit graph, so it wins
+ * over the kit's npm-semantics default — mirroring
+ * `Changesets.makeDepsRegenDefault`'s composition ("versionable minus
+ * ignored", identical to the savvy CLI).
  */
-declare const SilkRuntimeLive: Layer.Layer<Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.DepsRegen | Changesets.ReleasePlanner | Repos.ReposConfigStore | Repos.ReposManager | 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 makeSilkRuntimeLayer: (cwd: string) => Layer.Layer<McpServices, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
 //#endregion
 //#region src/server.d.ts
 /** Build the server and connect it over stdio. */
@@ -39,5 +51,5 @@ declare function startMcpServer(ctx: McpContext): Promise<void>;
  */
 declare const CURRENT_MCP_VERSION = "0.0.0";
 //#endregion
-export { CURRENT_MCP_VERSION, type McpContext, SilkRuntimeLive, startMcpServer };
+export { CURRENT_MCP_VERSION, type McpContext, type McpServices, makeSilkRuntimeLayer, startMcpServer };
 //# sourceMappingURL=index.d.ts.map

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "1.8.1",
+	"version": "2.0.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",
@@ -22,7 +22,8 @@
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
+			"import": "./index.js",
+			"default": "./index.js"
 		},
 		"./package.json": "./package.json"
 	},
@@ -30,17 +31,11 @@
 		"savvy-mcp": "bin/savvy-mcp.js"
 	},
 	"dependencies": {
-		"@effect/cluster": "^0.59.0",
-		"@effect/experimental": "^0.60.0",
-		"@effect/platform": "^0.96.2",
-		"@effect/platform-node": "^0.107.0",
-		"@effect/rpc": "^0.75.1",
-		"@effect/sql": "^0.51.1",
-		"@effect/workflow": "^0.18.2",
+		"@effect/platform-node": "4.0.0-beta.98",
+		"@effected/workspaces": "^0.3.0",
 		"@modelcontextprotocol/sdk": "^1.29.0",
-		"@savvy-web/silk-effects": "3.3.1",
-		"effect": "^3.21.4",
-		"workspaces-effect": "^2.1.0",
+		"@savvy-web/silk-effects": "4.0.0",
+		"effect": "4.0.0-beta.98",
 		"zod": "^4.4.3"
 	}
 }

package/runtime.js

@@ -1,71 +1,62 @@
-import { ChangesetConfigLive, ChangesetConfigReaderLive, Changesets, Repos, SilkWorkspaceAnalyzerLive, TagStrategyLive, ToolDiscoveryLive, Turbo, VersioningStrategyLive } from "@savvy-web/silk-effects";
+import { Workspaces } from "@effected/workspaces";
+import { ChangesetConfigLive, ChangesetConfigReaderLive, Changesets, PublishabilityDetectorAdaptiveLive, Repos, SilkWorkspaceAnalyzerLive, TagStrategyLive, ToolDiscoveryLive, Turbo, VersioningStrategyLive } from "@savvy-web/silk-effects";
 import { Layer } from "effect";
-import { PointInTimeWorkspaceLive, 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`.
+* {@link makeSilkRuntimeLayer} builds the full service graph for ONE workspace
+* root: the `@effected/workspaces` kit layers are root-bound at layer build
+* (single-root by design), so the server resolves its project directory once
+* at startup (bin.ts) and builds the layer with that root. The layer still
+* requires the platform services (`FileSystem` + `Path` +
+* `ChildProcessSpawner`); the host supplies them via `NodeServices.layer`.
 *
 * @packageDocumentation
 */
 /**
-* The silk-effects dependency set fed to {@link SilkWorkspaceAnalyzerLive}.
+* Build the MCP runtime layer for a workspace root. Provides
+* `SilkWorkspaceAnalyzer`, `WorkspaceRoot`, `Turbo.TurboInspector`,
+* `Changesets.BranchAnalyzer`, `Changesets.ConfigInspector`,
+* `Changesets.ReleasePlanner`, `Changesets.DepsRegen`, `Repos.ReposManager`,
+* and `Repos.ReposConfigStore`; requires `ChildProcessSpawner` + `FileSystem`
+* + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
 *
-* `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.
+* @remarks
+* The kit graph (`Workspaces.layerWithGit`) 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
+* the whole runtime a SINGLE `ConfigInspector` (the MCP server holds one for
+* its whole process lifetime, #229 — `changeset_inspect` refreshes it before
+* every call, and `BranchAnalyzer`, `ReleasePlanner`, and `DepsRegen` all read
+* through that shared instance). `DepsRegen` is gated by silk's adaptive
+* publishability detector — provided closer than the kit graph, so it wins
+* over the kit's npm-semantics default — mirroring
+* `Changesets.makeDepsRegenDefault`'s composition ("versionable minus
+* ignored", identical to the savvy CLI).
 */
-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 `PointInTimeWorkspace | ConfigInspector |
-* WorkspaceDiscovery | PublishabilityDetector | ChangesetConfig`. Here
-* `ConfigInspector` is provided via the shared {@link InspectorAndAnalyzerLive}
-* reference (so Effect memoizes the single `ConfigInspector` instance already
-* merged into the runtime), and `PointInTimeWorkspace` via
-* `PointInTimeWorkspaceLive` (whose `WorkspaceRoot`/`WorkspaceDiscovery` come
-* from `WorkspacesLive` inside {@link DepsLive}). `ChangesetConfig` is provided
-* its own `ChangesetConfigReaderLive` (already present in {@link DepsLive}, but
-* `Layer.mergeAll` does not cross-feed sibling layers). The remaining two —
-* `WorkspaceDiscovery`, `PublishabilityDetector` — are left open and satisfied
-* by `WorkspacesLive` inside {@link DepsLive}. `FileSystem` / `Path` /
-* `CommandExecutor` flow up to the host `NodeContext.layer`.
-*/
-const DepsRegenGroupLive = Changesets.DepsRegenLive.pipe(Layer.provide(InspectorAndAnalyzerLive), Layer.provide(PointInTimeWorkspaceLive), Layer.provide(ChangesetConfigLive.pipe(Layer.provide(ChangesetConfigReaderLive))));
-/**
-* `Repos.ReposManager` + `Repos.ReposConfigStore`, both exposed on the
-* runtime. `ReposManagerLive` requires `ReposConfigStore`, so it is given its
-* own `ReposConfigStoreLive` reference here (`Layer.mergeAll` does not
-* cross-feed sibling layers); `ReposConfigStore` is ALSO merged in directly so
-* `repos_inspect`'s config mode can resolve it on its own. The remaining
-* `CommandExecutor` + `FileSystem` + `Path` requirements flow up to the host
-* platform layer (`NodeContext.layer` in bin.ts).
-*/
-const ReposGroupLive = Layer.mergeAll(Repos.ReposConfigStoreLive, Repos.ReposManagerLive.pipe(Layer.provide(Repos.ReposConfigStoreLive)));
-/**
-* The MCP runtime layer. Provides `SilkWorkspaceAnalyzer`, `WorkspaceRoot`,
-* `Turbo.TurboInspector`, `Changesets.BranchAnalyzer`,
-* `Changesets.ConfigInspector`, `Changesets.ReleasePlanner`,
-* `Changesets.DepsRegen`, `Repos.ReposManager`, and `Repos.ReposConfigStore`;
-* 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, DepsRegenGroupLive, ReposGroupLive).pipe(Layer.provide(DepsLive));
+const makeSilkRuntimeLayer = (cwd) => {
+	const kitGraph = Workspaces.layerWithGit({ cwd });
+	const analyzerDeps = Layer.mergeAll(ChangesetConfigReaderLive, TagStrategyLive, VersioningStrategyLive.pipe(Layer.provide(ChangesetConfigReaderLive)));
+	/**
+	* `BranchAnalyzer` + `ReleasePlanner` + the ONE shared `ConfigInspector`,
+	* merged so all three land on the runtime and every internal consumer
+	* memoizes onto the same inspector reference.
+	*/
+	const inspectorAndAnalyzer = Changesets.BranchAnalyzerLive.pipe(Layer.provideMerge(Changesets.ReleasePlannerLive), Layer.provideMerge(Changesets.ConfigInspectorLive.pipe(Layer.provide(ChangesetConfigReaderLive))));
+	const changesetConfig = ChangesetConfigLive.pipe(Layer.provide(ChangesetConfigReaderLive));
+	const depsRegen = Changesets.DepsRegenLive.pipe(Layer.provide(inspectorAndAnalyzer), Layer.provide(PublishabilityDetectorAdaptiveLive.pipe(Layer.provide(changesetConfig))), Layer.provide(changesetConfig));
+	/**
+	* `ReposManagerLive` requires `ReposConfigStore`, so it is given its own
+	* `ReposConfigStoreLive` reference; the store is ALSO merged in directly so
+	* `repos_inspect`'s config mode can resolve it on its own. Same reference —
+	* one store instance.
+	*/
+	const repos = Layer.mergeAll(Repos.ReposConfigStoreLive, Repos.ReposManagerLive.pipe(Layer.provide(Repos.ReposConfigStoreLive)));
+	return Layer.mergeAll(SilkWorkspaceAnalyzerLive.pipe(Layer.provide(analyzerDeps)), Turbo.TurboInspectorLive.pipe(Layer.provide(ToolDiscoveryLive)), inspectorAndAnalyzer, depsRegen, repos).pipe(Layer.provideMerge(kitGraph));
+};
 
 //#endregion
-export { SilkRuntimeLive };
+export { makeSilkRuntimeLayer };

package/schema/effect-to-zod.js

@@ -1,54 +1,205 @@
-import { JSONSchema } from "effect";
+import { Schema } 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`.
+* Bridge an Effect Schema to a zod schema by routing through JSON Schema, so a
+* tool keeps Effect Schema as the canonical source of truth while the MCP SDK
+* receives the zod instance its `registerTool` API requires.
+*
+* @packageDocumentation
+*/
+/**
+* Convert an Effect `Schema.Codec<A, I>` to a zod schema:
+* `Schema.toJsonSchemaDocument`, then inline every `#/$defs/*` `$ref` and
+* normalize back to the wire contract, 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
+*   make the inlining pass 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 jsonSchema = JSONSchema.make(schema);
-	const inlined = inlineAllRefs(jsonSchema);
+	const inlined = effectSchemaToInlinedJsonSchema(schema);
 	const zodSchema = z.fromJSONSchema(inlined);
 	if (isObjectLike(zodSchema)) return zodSchema;
 	return z.object({}).catchall(z.unknown());
 };
 const isObjectLike = (schema) => schema instanceof z.ZodObject;
+/**
+* Produce the inlined, normalized JSON Schema object handed to
+* `z.fromJSONSchema`. Exposed separately so schema-snapshot tooling can
+* serialize exactly what the bridge feeds zod.
+*
+* @remarks
+* v4's `Schema.toJsonSchemaDocument` returns `{ dialect, schema, definitions }`
+* with every identifier-annotated subschema hoisted into `definitions` and
+* referenced as `#/$defs/<name>` — including the root itself. Two v4 encoding
+* changes are normalized back to the v3-era wire contract here (in the bridge,
+* never in the public schemas):
+*
+* - `Schema.Number` now encodes non-finite values as strings, emitting
+*   `anyOf: [number, "NaN", "Infinity", "-Infinity"]`. Tool results never
+*   carry non-finite numbers, so this collapses to `{ type: "number" }`.
+* - `Schema.optional(S)` now admits `undefined`, emitting
+*   `anyOf: [S, { type: "null" }]` on the (already non-required) key. The
+*   handlers build results with conditional spreads and never emit
+*   `undefined`/`null` for optional keys, so the null arm is dropped.
+*   Deliberate `Schema.NullOr` fields are all on required keys and keep
+*   their null arm.
+* - Filter checks (`isMinLength`, `isPattern`, …) now emit as
+*   `allOf: [{ minLength: 1 }]` instead of inline keywords. Bare-constraint
+*   `allOf` members are folded back into the parent node.
+*/
+const effectSchemaToInlinedJsonSchema = (schema) => {
+	const doc = Schema.toJsonSchemaDocument(schema);
+	return inlineAllRefs(doc.schema, doc.definitions);
+};
 const REF_PREFIX = "#/$defs/";
+/** A JSON-schema node matching `{ "type": "null" }` exactly. */
+const isNullSchema = (value) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const obj = value;
+	return obj.type === "null" && Object.keys(obj).length === 1;
+};
+/** A JSON-schema node matching `{ "type": "string", "enum": ["NaN" | "Infinity" | "-Infinity"] }`. */
+const isNonFiniteArm = (value) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const obj = value;
+	if (obj.type !== "string" || !Array.isArray(obj.enum) || obj.enum.length !== 1) return false;
+	const literal = obj.enum[0];
+	return literal === "NaN" || literal === "Infinity" || literal === "-Infinity";
+};
+/** A JSON-schema node matching `{ "type": "number" }` exactly. */
+const isPlainNumberArm = (value) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const obj = value;
+	return obj.type === "number" && Object.keys(obj).length === 1;
+};
+/** JSON-schema keywords that are pure value constraints (no structural meaning). */
+const CONSTRAINT_KEYS = /* @__PURE__ */ new Set([
+	"minLength",
+	"maxLength",
+	"pattern",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"minItems",
+	"maxItems",
+	"format"
+]);
+/** A node whose every key is a pure value-constraint keyword. */
+const isBareConstraint = (value) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const keys = Object.keys(value);
+	return keys.length > 0 && keys.every((k) => CONSTRAINT_KEYS.has(k));
+};
+/**
+* Fold `allOf` members that are bare constraint objects — v4's encoding of
+* filter checks — back into the parent node (v3 inlined them). Keys already
+* present on the parent are left inside `allOf` untouched.
+*/
+const flattenConstraintAllOf = (node) => {
+	const allOf = node.allOf;
+	if (!Array.isArray(allOf)) return node;
+	const remaining = [];
+	const folded = {};
+	for (const member of allOf) {
+		if (!isBareConstraint(member) || Object.keys(member).some((k) => k in node || k in folded)) {
+			remaining.push(member);
+			continue;
+		}
+		Object.assign(folded, member);
+	}
+	if (Object.keys(folded).length === 0) return node;
+	const { allOf: _dropped, ...rest } = node;
+	return remaining.length > 0 ? {
+		...rest,
+		...folded,
+		allOf: remaining
+	} : {
+		...rest,
+		...folded
+	};
+};
+/**
+* Collapse v4's non-finite number encoding — `anyOf: [{ type: "number" },
+* "NaN", "Infinity", "-Infinity"]` — to `{ type: "number" }`, keeping any
+* sibling annotations (description, title) on the node.
+*/
+const collapseNonFiniteNumber = (node) => {
+	const anyOf = node.anyOf;
+	if (!Array.isArray(anyOf) || anyOf.length !== 4) return node;
+	const numberArms = anyOf.filter(isPlainNumberArm);
+	const nonFiniteArms = anyOf.filter(isNonFiniteArm);
+	if (numberArms.length !== 1 || nonFiniteArms.length !== 3) return node;
+	const { anyOf: _dropped, ...siblings } = node;
+	return {
+		type: "number",
+		...siblings
+	};
+};
+/**
+* Drop the `{ type: "null" }` arm that v4's `Schema.optional` adds for its
+* `undefined` case. Applied only to non-required properties, so deliberate
+* `Schema.NullOr` fields (all on required keys) keep their null arm.
+*/
+const dropUndefinedArm = (node) => {
+	if (node === null || typeof node !== "object" || Array.isArray(node)) return node;
+	const obj = node;
+	if (!Array.isArray(obj.anyOf)) return obj;
+	const arms = obj.anyOf.filter((arm) => !isNullSchema(arm));
+	if (arms.length === obj.anyOf.length) return obj;
+	const { anyOf: _dropped, ...siblings } = obj;
+	if (arms.length === 1 && arms[0] !== null && typeof arms[0] === "object" && !Array.isArray(arms[0])) return collapseNonFiniteNumber({
+		...arms[0],
+		...siblings
+	});
+	return collapseNonFiniteNumber({
+		anyOf: arms,
+		...siblings
+	});
+};
 /**
-* Replace every `$ref: "#/$defs/X"` node with the contents of `$defs.X`,
-* recursively, and drop the `$defs` table. Assumes acyclic refs.
+* Replace every `$ref: "#/$defs/X"` node with the contents of
+* `definitions.X`, recursively, and normalize the v4 encoding deltas back to
+* the wire contract. Assumes acyclic refs.
 */
-const inlineAllRefs = (root) => {
-	const defs = root.$defs ?? {};
+const inlineAllRefs = (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 defName = obj.$ref.slice(8);
-			const target = defs[defName];
+			const target = defs[obj.$ref.slice(8)];
 			if (target !== void 0) return visit(target);
 		}
+		const required = Array.isArray(obj.required) ? obj.required : [];
 		const out = {};
 		for (const [k, v] of Object.entries(obj)) {
 			if (k === "$defs") continue;
+			if (k === "properties" && v !== null && typeof v === "object" && !Array.isArray(v)) {
+				const props = {};
+				for (const [propKey, propValue] of Object.entries(v)) {
+					const visited = visit(propValue);
+					props[propKey] = required.includes(propKey) ? visited : dropUndefinedArm(visited);
+				}
+				out[k] = props;
+				continue;
+			}
 			out[k] = visit(v);
 		}
-		return out;
+		return collapseNonFiniteNumber(flattenConstraintAllOf(out));
 	};
 	return visit(root);
 };
 
 //#endregion
-export { effectToZodSchema };
+export { effectSchemaToInlinedJsonSchema, effectToZodSchema };

package/server.js

@@ -43,7 +43,7 @@ function buildServer(ctx) {
 	}, async (args) => {
 		const root = args.cwd ?? ctx.cwd;
 		const data = await ctx.runtime.runPromise(workspaceInfo(root));
-		const text = Schema.decodeSync(WorkspaceInfoAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(WorkspaceInfoAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("turbo_inspect", {
@@ -62,7 +62,7 @@ function buildServer(ctx) {
 		annotations: { readOnlyHint: true }
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(turboInspect(args, ctx.cwd));
-		const text = Schema.decodeSync(TurboInspectAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(TurboInspectAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_inspect", {
@@ -81,7 +81,7 @@ function buildServer(ctx) {
 		annotations: { readOnlyHint: true }
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(changesetInspect(args, ctx.cwd));
-		const text = Schema.decodeSync(ChangesetInspectAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ChangesetInspectAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_validate", {
@@ -94,7 +94,7 @@ function buildServer(ctx) {
 		annotations: { readOnlyHint: true }
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(changesetValidate(args, ctx.cwd));
-		const text = Schema.decodeSync(ChangesetValidateAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ChangesetValidateAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_deps_detect", {
@@ -110,7 +110,7 @@ function buildServer(ctx) {
 		annotations: { readOnlyHint: true }
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(changesetDepsDetect(args, ctx.cwd));
-		const text = Schema.decodeSync(ChangesetDepsDetectAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ChangesetDepsDetectAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_preview", {
@@ -120,7 +120,7 @@ function buildServer(ctx) {
 		annotations: { readOnlyHint: true }
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(changesetPreview(args, ctx.cwd));
-		const text = Schema.decodeSync(ChangesetPreviewAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ChangesetPreviewAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("changeset_deps_regen", {
@@ -140,7 +140,7 @@ function buildServer(ctx) {
 		}
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(changesetDepsRegen(args, ctx.cwd));
-		const text = Schema.decodeSync(ChangesetDepsRegenAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ChangesetDepsRegenAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("repos_inspect", {
@@ -154,7 +154,7 @@ function buildServer(ctx) {
 		annotations: { readOnlyHint: true }
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(reposInspect(args, ctx.cwd));
-		const text = Schema.decodeSync(ReposInspectAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ReposInspectAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("repos_manage", {
@@ -189,7 +189,7 @@ function buildServer(ctx) {
 		}
 	}, async (args) => {
 		const data = await ctx.runtime.runPromise(reposManage(args, ctx.cwd));
-		const text = Schema.decodeSync(ReposManageAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(ReposManageAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	server.registerTool("biome_check", {
@@ -205,7 +205,7 @@ function buildServer(ctx) {
 		outputSchema: effectToZodSchema(BiomeCheckResult)
 	}, async (args) => {
 		const data = await runBiomeCheck(args, ctx.cwd);
-		const text = Schema.decodeSync(BiomeCheckAsMarkdown)(data);
+		const text = Schema.decodeUnknownSync(BiomeCheckAsMarkdown)(data);
 		return structuredResult(text, data);
 	});
 	return server;

package/tools/biome-check.js

@@ -1,5 +1,5 @@
 import { Lint } from "@savvy-web/silk-effects";
-import { ParseResult, Schema } from "effect";
+import { Schema, SchemaGetter } from "effect";
 import { spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
@@ -14,7 +14,11 @@ import { relative, resolve, sep } from "node:path";
 * @packageDocumentation
 */
 /** Normalized diagnostic severity. */
-const BiomeSeverity = Schema.Literal("error", "warning", "info");
+const BiomeSeverity = Schema.Literals([
+	"error",
+	"warning",
+	"info"
+]);
 /** A single normalized Biome diagnostic. */
 const BiomeDiagnostic = Schema.Struct({
 	file: Schema.String,
@@ -24,7 +28,7 @@ const BiomeDiagnostic = Schema.Struct({
 	message: Schema.String,
 	/** Present only when `strict` upgraded this diagnostic; holds the project-configured severity. */
 	originalSeverity: Schema.optional(BiomeSeverity)
-}).annotations({ identifier: "BiomeDiagnostic" });
+}).annotate({ identifier: "BiomeDiagnostic" });
 /** The `biome_check` tool result. */
 const BiomeCheckResult = Schema.Struct({
 	summary: Schema.Struct({
@@ -36,7 +40,7 @@ const BiomeCheckResult = Schema.Struct({
 	diagnostics: Schema.Array(BiomeDiagnostic),
 	wrote: Schema.Boolean,
 	guidance: Schema.String
-}).annotations({
+}).annotate({
 	identifier: "BiomeCheckResult",
 	title: "biome_check result",
 	description: "Structured Biome diagnostics, with a flag for whether a --write pass ran."
@@ -51,7 +55,13 @@ const GUIDANCE_STRICT_NOTE = "Diagnostics marked with originalSeverity are proje
 const GitlabDiagnostic = Schema.Struct({
 	description: Schema.String,
 	check_name: Schema.String,
-	severity: Schema.Literal("info", "minor", "major", "critical", "blocker"),
+	severity: Schema.Literals([
+		"info",
+		"minor",
+		"major",
+		"critical",
+		"blocker"
+	]),
 	location: Schema.Struct({
 		path: Schema.String,
 		lines: Schema.Struct({ begin: Schema.Number })
@@ -128,11 +138,10 @@ const renderMarkdown = (data) => {
 	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."))
-});
+const BiomeCheckAsMarkdown = BiomeCheckResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "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.

package/tools/changeset-deps-detect.js

@@ -1,29 +1,19 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "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" });
+}).annotate({ identifier: "ChangesetDepsDetectPackage" });
 /** The `changeset_deps_detect` tool result. */
 const ChangesetDepsDetectResult = Schema.Struct({
 	root: Schema.String,
 	packages: Schema.Array(ChangesetDepsDetectPackage)
-}).annotations({
+}).annotate({
 	identifier: "ChangesetDepsDetectResult",
 	title: "changeset_deps_detect result",
 	description: "Read-only per-package dependency diff (devDependencies retained). No files are written."
@@ -56,11 +46,10 @@ const renderMarkdown = (data) => {
 	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."))
-});
+const ChangesetDepsDetectAsMarkdown = ChangesetDepsDetectResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ChangesetDepsDetectAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, then compute the cumulative
 * dependency diff via {@link Changesets.DepsRegen.plan} with `includeDevDeps`

package/tools/changeset-deps-regen.js

@@ -1,17 +1,8 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "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,
@@ -19,7 +10,7 @@ const ChangesetDepsRegenResult = Schema.Struct({
 	written: Schema.Array(Schema.String),
 	skippedMixed: Schema.Array(Schema.String),
 	dryRun: Schema.Boolean
-}).annotations({
+}).annotate({
 	identifier: "ChangesetDepsRegenResult",
 	title: "changeset_deps_regen result",
 	description: "Regenerated pure-dependency changesets. Mutates .changeset/*.md unless dryRun is set."
@@ -60,11 +51,10 @@ const renderMarkdown = (data) => {
 	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."))
-});
+const ChangesetDepsRegenAsMarkdown = ChangesetDepsRegenResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ChangesetDepsRegenAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, compute a {@link Changesets.RegenPlan}
 * via {@link Changesets.DepsRegen.plan}, then — unless `dryRun` — apply it via

package/tools/changeset-inspect.js

@@ -1,33 +1,29 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "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" });
+}).annotate({ identifier: "ChangesetBranchResult" });
 /** Config-inspection variant. */
 const ChangesetConfigResult = Schema.Struct({
 	mode: Schema.Literal("config"),
 	result: Changesets.InspectedConfigSchema
-}).annotations({ identifier: "ChangesetConfigResult" });
+}).annotate({ identifier: "ChangesetConfigResult" });
 /** Classify variant — arbitrary paths to owning package. */
 const ChangesetClassifyResult = Schema.Struct({
 	mode: Schema.Literal("classify"),
 	result: Schema.Array(Changesets.ClassificationSchema)
-}).annotations({ identifier: "ChangesetClassifyResult" });
+}).annotate({ identifier: "ChangesetClassifyResult" });
 /** The `changeset_inspect` tool result — a discriminated union keyed by `mode`. */
-const ChangesetInspectResult = Schema.Union(ChangesetBranchResult, ChangesetConfigResult, ChangesetClassifyResult).annotations({
+const ChangesetInspectResult = Schema.Union([
+	ChangesetBranchResult,
+	ChangesetConfigResult,
+	ChangesetClassifyResult
+]).annotate({
 	identifier: "ChangesetInspectResult",
 	title: "changeset_inspect result",
 	description: "Read-only changeset analysis grouped by mode (branch | config | classify)."
@@ -95,11 +91,10 @@ const renderMarkdown = (data) => {
 	}
 };
 /** 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."))
-});
+const ChangesetInspectAsMarkdown = ChangesetInspectResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ChangesetInspectAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, then dispatch to the matching
 * Changesets service keyed by `mode`. Mirrors `turboInspect`.

package/tools/changeset-preview.js

@@ -1,17 +1,10 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/changeset-preview.ts
-/**
-* The `changeset_preview` MCP tool: a read-only preview of the next release's
-* CHANGELOG, produced by the genuine changesets engine via silk-effects'
-* ReleasePlanner. Structured result + one-way markdown transform. Read-only.
-*
-* @packageDocumentation
-*/
 /** The `changeset_preview` result — the silk-effects preview shape. */
-const ChangesetPreviewResult = Changesets.ChangesetPreviewSchema.annotations({
+const ChangesetPreviewResult = Changesets.ChangesetPreviewSchema.annotate({
 	identifier: "ChangesetPreviewResult",
 	title: "changeset_preview result",
 	description: "Read-only preview of the next release: version bumps + rendered CHANGELOG blocks."
@@ -34,11 +27,10 @@ const renderMarkdown = (data) => {
 	return lines.join("\n").trimEnd();
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
-const ChangesetPreviewAsMarkdown = Schema.transformOrFail(ChangesetPreviewResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "ChangesetPreviewAsMarkdown is one-way: markdown cannot be parsed back."))
-});
+const ChangesetPreviewAsMarkdown = ChangesetPreviewResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ChangesetPreviewAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, then render the preview via
 * ReleasePlanner. Mirrors `changesetInspect`.

package/tools/changeset-validate.js

@@ -1,6 +1,6 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets } from "@savvy-web/silk-effects";
-import { Data, Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Data, Effect, Schema, SchemaGetter } from "effect";
 import { resolve } from "node:path";
 
 //#region src/tools/changeset-validate.ts
@@ -20,14 +20,14 @@ const ChangesetLintMessage = Schema.Struct({
 	line: Schema.Number,
 	column: Schema.Number,
 	message: Schema.String
-}).annotations({ identifier: "ChangesetLintMessage" });
+}).annotate({ identifier: "ChangesetLintMessage" });
 /** The `changeset_validate` tool result. */
 const ChangesetValidateResult = Schema.Struct({
 	dir: Schema.String,
 	ok: Schema.Boolean,
 	errorCount: Schema.Number,
 	messages: Schema.Array(ChangesetLintMessage)
-}).annotations({
+}).annotate({
 	identifier: "ChangesetValidateResult",
 	title: "changeset_validate result",
 	description: "Read-only validation of changeset files against the section-aware rules."
@@ -51,11 +51,10 @@ const renderMarkdown = (data) => {
 	return lines.join("\n");
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
-const ChangesetValidateAsMarkdown = Schema.transformOrFail(ChangesetValidateResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "ChangesetValidateAsMarkdown is one-way: markdown cannot be parsed back."))
-});
+const ChangesetValidateAsMarkdown = ChangesetValidateResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ChangesetValidateAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, then validate the changeset
 * directory via the pure {@link Changesets.ChangesetLinter.validate}. The

package/tools/repos-inspect.js

@@ -1,29 +1,21 @@
 import { mdInline } from "./md-inline.js";
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Repos } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/repos-inspect.ts
-/**
-* The `repos_inspect` MCP tool: a discriminated-union result keyed by `mode`
-* (status | config), each variant embedding the corresponding resolved-output
-* schema from silk-effects' Repos namespace, plus a one-way markdown
-* transform. Read-only.
-*
-* @packageDocumentation
-*/
 /** Status-report variant. */
 const ReposStatusResult = Schema.Struct({
 	mode: Schema.Literal("status"),
 	result: Repos.ReposStatusReport
-}).annotations({ identifier: "ReposStatusResult" });
+}).annotate({ identifier: "ReposStatusResult" });
 /** Manifest-config variant. */
 const ReposConfigResult = Schema.Struct({
 	mode: Schema.Literal("config"),
 	result: Repos.ReposManifestFile
-}).annotations({ identifier: "ReposConfigResult" });
+}).annotate({ identifier: "ReposConfigResult" });
 /** The `repos_inspect` tool result — a discriminated union keyed by `mode`. */
-const ReposInspectResult = Schema.Union(ReposStatusResult, ReposConfigResult).annotations({
+const ReposInspectResult = Schema.Union([ReposStatusResult, ReposConfigResult]).annotate({
 	identifier: "ReposInspectResult",
 	title: "repos_inspect result",
 	description: "Drift report (status) or the parsed manifest with purposes, orientation, and notes (config)."
@@ -77,11 +69,10 @@ const renderMarkdown = (data) => {
 	}
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
-const ReposInspectAsMarkdown = Schema.transformOrFail(ReposInspectResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "ReposInspectAsMarkdown is one-way: markdown cannot be parsed back."))
-});
+const ReposInspectAsMarkdown = ReposInspectResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ReposInspectAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, then dispatch to the matching
 * Repos service keyed by `mode`. Mirrors `changesetInspect`.

package/tools/repos-manage.js

@@ -1,18 +1,9 @@
 import { mdInline } from "./md-inline.js";
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Repos } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/repos-manage.ts
-/**
-* The `repos_manage` MCP tool: one action-discriminated mutating tool
-* covering `sync`, `pin`, `add`, and `note` against the vendored `.repos/`
-* submodules. The wire schema is flat (no `oneOf`); the handler maps it into
-* an internal `Schema.TaggedStruct` request union that names the missing
-* field per action on decode failure. Mutating — no `readOnlyHint`.
-*
-* @packageDocumentation
-*/
 /** `sync` has no extra fields. */
 const SyncRequest = Schema.TaggedStruct("sync", {});
 /** `pin` requires both `name` and `ref`. */
@@ -35,40 +26,54 @@ const AddRequest = Schema.TaggedStruct("add", {
 */
 const NoteRequest = Schema.TaggedStruct("note", {
 	name: Schema.String,
-	op: Schema.Literal("add", "remove", "promote"),
+	op: Schema.Literals([
+		"add",
+		"remove",
+		"promote"
+	]),
 	note: Schema.optional(Schema.String),
 	id: Schema.optional(Schema.String),
-	into: Schema.optional(Schema.Literal("layout", "startHere"))
-}).pipe(Schema.filter((request) => {
+	into: Schema.optional(Schema.Literals(["layout", "startHere"]))
+}).check(Schema.makeFilter((request) => {
 	if (request.op === "add" && request.note === void 0) return "note op \"add\" requires `note`";
 	if (request.op === "remove" && request.id === void 0) return "note op \"remove\" requires `id`";
 	if (request.op === "promote" && (request.id === void 0 || request.into === void 0)) return "note op \"promote\" requires both `id` and `into`";
 	return true;
 }));
 /** Internal tagged-union request the flat wire args decode into. */
-const ReposManageRequest = Schema.Union(SyncRequest, PinRequest, AddRequest, NoteRequest);
+const ReposManageRequest = Schema.Union([
+	SyncRequest,
+	PinRequest,
+	AddRequest,
+	NoteRequest
+]);
 /** `sync` result variant. */
 const ReposManageSyncResult = Schema.Struct({
 	action: Schema.Literal("sync"),
 	result: Repos.ReposSyncReport
-}).annotations({ identifier: "ReposManageSyncResult" });
+}).annotate({ identifier: "ReposManageSyncResult" });
 /** `pin` result variant. */
 const ReposManagePinResult = Schema.Struct({
 	action: Schema.Literal("pin"),
 	result: Repos.ReposPinResult
-}).annotations({ identifier: "ReposManagePinResult" });
+}).annotate({ identifier: "ReposManagePinResult" });
 /** `add` result variant. */
 const ReposManageAddResult = Schema.Struct({
 	action: Schema.Literal("add"),
 	result: Repos.ReposAddResult
-}).annotations({ identifier: "ReposManageAddResult" });
+}).annotate({ identifier: "ReposManageAddResult" });
 /** `note` result variant. */
 const ReposManageNoteResult = Schema.Struct({
 	action: Schema.Literal("note"),
 	result: Repos.ReposNoteResult
-}).annotations({ identifier: "ReposManageNoteResult" });
+}).annotate({ identifier: "ReposManageNoteResult" });
 /** The `repos_manage` tool result — a discriminated union keyed by `action`. */
-const ReposManageResult = Schema.Union(ReposManageSyncResult, ReposManagePinResult, ReposManageAddResult, ReposManageNoteResult).annotations({
+const ReposManageResult = Schema.Union([
+	ReposManageSyncResult,
+	ReposManagePinResult,
+	ReposManageAddResult,
+	ReposManageNoteResult
+]).annotate({
 	identifier: "ReposManageResult",
 	title: "repos_manage result",
 	description: "Result of a mutating repos action: sync, pin, add, or note."
@@ -134,11 +139,10 @@ const renderMarkdown = (data) => {
 	}
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
-const ReposManageAsMarkdown = Schema.transformOrFail(ReposManageResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "ReposManageAsMarkdown is one-way: markdown cannot be parsed back."))
-});
+const ReposManageAsMarkdown = ReposManageResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "ReposManageAsMarkdown is one-way: markdown cannot be parsed back.")
+}));
 /**
 * Effect handler: resolve the workspace root, decode the flat wire args into
 * the internal per-action request (naming the missing field on failure), then
@@ -148,7 +152,7 @@ const reposManage = (args, fallbackCwd) => Effect.gen(function* () {
 	const root = yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd);
 	const manager = yield* Repos.ReposManager;
 	const { action, cwd: _cwd, ...rest } = args;
-	const request = yield* Schema.decodeUnknown(ReposManageRequest)({
+	const request = yield* Schema.decodeUnknownEffect(ReposManageRequest)({
 		_tag: action,
 		...rest
 	});

package/tools/turbo-inspect.js

@@ -1,32 +1,29 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { Turbo } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "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" });
+}).annotate({ identifier: "TurboCacheResult" });
 /** Task-graph variant of the `turbo_inspect` result. */
 const TurboGraphResult = Schema.Struct({
 	mode: Schema.Literal("graph"),
 	result: Turbo.TaskGraphResult
-}).annotations({ identifier: "TurboGraphResult" });
+}).annotate({ identifier: "TurboGraphResult" });
 /** Affected-packages variant of the `turbo_inspect` result. */
 const TurboAffectedResult = Schema.Struct({
 	mode: Schema.Literal("affected"),
 	result: Turbo.AffectedResult
-}).annotations({ identifier: "TurboAffectedResult" });
+}).annotate({ identifier: "TurboAffectedResult" });
 /** The `turbo_inspect` tool result — a discriminated union keyed by `mode`. */
-const TurboInspectResult = Schema.Union(TurboCacheResult, TurboGraphResult, TurboAffectedResult).annotations({
+const TurboInspectResult = Schema.Union([
+	TurboCacheResult,
+	TurboGraphResult,
+	TurboAffectedResult
+]).annotate({
 	identifier: "TurboInspectResult",
 	title: "turbo_inspect result",
 	description: "Read-only Turborepo inspection grouped by mode (cache | graph | affected)."
@@ -80,11 +77,10 @@ const renderMarkdown = (data) => {
 	}
 };
 /** 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."))
-});
+const TurboInspectAsMarkdown = TurboInspectResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(renderMarkdown),
+	encode: SchemaGetter.forbidden(() => "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

package/tools/workspace-info.js

@@ -1,6 +1,6 @@
+import { WorkspaceRoot } from "@effected/workspaces";
 import { SilkWorkspaceAnalyzer } from "@savvy-web/silk-effects";
-import { Effect, ParseResult, Schema } from "effect";
-import { WorkspaceRoot } from "workspaces-effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/workspace-info.ts
 /** A flattened, non-recursive summary of one analyzed workspace. */
@@ -10,24 +10,29 @@ const WorkspaceSummary = Schema.Struct({
 	path: Schema.String,
 	root: Schema.Boolean,
 	publishable: Schema.Boolean,
-	targets: Schema.Array(Schema.String).annotations({ description: "Publish registry URLs." }),
+	targets: Schema.Array(Schema.String).annotate({ 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" });
+	linked: Schema.Array(Schema.String).annotate({ description: "Names of linked workspaces." }),
+	fixed: Schema.Array(Schema.String).annotate({ description: "Names of fixed-group siblings." })
+}).annotate({ identifier: "WorkspaceSummary" });
 /** The `workspace_info` tool result — a projection of `WorkspaceAnalysis`. */
 const WorkspaceInfoResult = Schema.Struct({
 	root: Schema.String,
-	runtime: Schema.Literal("node", "bun"),
+	runtime: Schema.Literals(["node", "bun"]),
 	packageManager: Schema.Struct({
-		type: Schema.Literal("npm", "pnpm", "yarn", "bun"),
+		type: Schema.Literals([
+			"npm",
+			"pnpm",
+			"yarn",
+			"bun"
+		]),
 		version: Schema.optional(Schema.String)
 	}),
 	workspaceCount: Schema.Number,
 	workspaces: Schema.Array(WorkspaceSummary)
-}).annotations({
+}).annotate({
 	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)."
@@ -73,11 +78,10 @@ const formatWorkspaceInfoMarkdown = (data) => {
 	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."))
-});
+const WorkspaceInfoAsMarkdown = WorkspaceInfoResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(formatWorkspaceInfoMarkdown),
+	encode: SchemaGetter.forbidden(() => "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`