@savvy-web/mcp 2.7.4 → 3.0.0

package/index.d.ts

@@ -1,10 +1,134 @@
+import { Context, FileSystem, Layer, Path, Schema, Stdio } from "effect";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Changesets, Repos, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
-import { FileSystem, Layer, ManagedRuntime, Path } from "effect";
 import { ChildProcessSpawner } from "effect/unstable/process";
-import "@modelcontextprotocol/sdk/server/mcp.js";
-import "zod";
-//#region src/context.d.ts
+import { Tool, Toolkit } from "effect/unstable/ai";
+//#region src/errors.d.ts
+/** What a caller should do next about a failed tool call. @public */
+export declare const Remediation: Schema.Struct<{
+  readonly hint: Schema.String;
+  readonly suggestedTool: Schema.optionalKey<Schema.String>;
+}>;
+/** @public */
+export type Remediation = typeof Remediation.Type;
+/**
+ * Compose a self-contained wire message from a raw cause message and its
+ * remediation: the human message, then the hint, then `Try <suggestedTool>.`
+ * when one is present. Every {@link McpToolError} member's `message` is built
+ * through this at construction, because `message` is the only field a
+ * declared failure delivers to the wire.
+ *
+ * @public
+ */
+export declare const composeRemediatedMessage: (message: string, remediation: Remediation) => string;
+/**
+ * Truncate a caller-supplied value before it is echoed back inside an error's
+ * `message`. Without this a pathological argument (a multi-megabyte `cwd`,
+ * say) is echoed once in the response's `content[0].text` and once more in the
+ * corresponding log line, burning an agent's context twice on what is usually
+ * a typo.
+ *
+ * @public
+ */
+export declare const truncateEchoed: (value: string, limit?: number) => string;
+declare const WorkspaceNotFound_base: Schema.Class<WorkspaceNotFound, Schema.TaggedStruct<"WorkspaceNotFound", {
+  readonly cwd: Schema.String;
+  readonly message: Schema.String;
+  readonly remediation: Schema.Struct<{
+    readonly hint: Schema.String;
+    readonly suggestedTool: Schema.optionalKey<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No workspace root was found walking up from the requested directory.
+ * `message` is composed through {@link composeRemediatedMessage} at
+ * construction, so it is what reaches the wire as `content[0].text`.
+ *
+ * @public
+ */
+export declare class WorkspaceNotFound extends WorkspaceNotFound_base {}
+declare const InvalidArgument_base: Schema.Class<InvalidArgument, Schema.TaggedStruct<"InvalidArgument", {
+  readonly argument: Schema.String;
+  readonly message: Schema.String;
+  readonly remediation: Schema.Struct<{
+    readonly hint: Schema.String;
+    readonly suggestedTool: Schema.optionalKey<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A tool argument was structurally acceptable but semantically invalid — a
+ * `repos_manage` action missing the field it needs, a `biome_check` path
+ * outside the workspace, a `changeset_validate` directory that does not
+ * exist. `message` is composed through {@link composeRemediatedMessage}.
+ *
+ * @public
+ */
+export declare class InvalidArgument extends InvalidArgument_base {}
+declare const EngineError_base: Schema.Class<EngineError, Schema.TaggedStruct<"EngineError", {
+  readonly source: Schema.String;
+  readonly message: Schema.String;
+  readonly remediation: Schema.Struct<{
+    readonly hint: Schema.String;
+    readonly suggestedTool: Schema.optionalKey<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A silk-effects engine program failed with one of its own typed errors
+ * (`TurboError`, `GitError`, `ReposConfigError`, …). `source` carries that
+ * error's `_tag`; `message` is its own rendering plus the remediation,
+ * composed through {@link composeRemediatedMessage}.
+ *
+ * @public
+ */
+export declare class EngineError extends EngineError_base {}
+declare const BiomeUnavailable_base: Schema.Class<BiomeUnavailable, Schema.TaggedStruct<"BiomeUnavailable", {
+  readonly message: Schema.String;
+  readonly remediation: Schema.Struct<{
+    readonly hint: Schema.String;
+    readonly suggestedTool: Schema.optionalKey<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No Biome binary could be located. `message` is composed through
+ * {@link composeRemediatedMessage}.
+ *
+ * @public
+ */
+export declare class BiomeUnavailable extends BiomeUnavailable_base {}
+declare const BiomeFailed_base: Schema.Class<BiomeFailed, Schema.TaggedStruct<"BiomeFailed", {
+  readonly exitCode: Schema.optionalKey<Schema.Number>;
+  readonly message: Schema.String;
+  readonly remediation: Schema.Struct<{
+    readonly hint: Schema.String;
+    readonly suggestedTool: Schema.optionalKey<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Biome itself failed (exit status above 1, a spawn error, or a timeout) —
+ * distinct from "lint issues found", which is a successful result. `message`
+ * is composed through {@link composeRemediatedMessage}.
+ *
+ * @public
+ */
+export declare class BiomeFailed extends BiomeFailed_base {}
+/** The one failure schema every savvy-mcp tool declares. @public */
+export declare const McpToolError: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+/** @public */
+export type McpToolError = typeof McpToolError.Type;
+//#endregion
+//#region src/markdown.d.ts
+declare const SilkMarkdown_base: Context.ServiceClass<SilkMarkdown, "@savvy-web/mcp/SilkMarkdown", (data: unknown) => string>;
+/**
+ * Renders a tool's decoded success value as the markdown transcript an agent
+ * reads. Typed over `unknown` because the annotation is read generically at
+ * registration; each tool supplies `Schema.decodeUnknownSync(<X>AsMarkdown)`,
+ * whose own decoder is the type guard.
+ *
+ * @public
+ */
+export declare class SilkMarkdown extends SilkMarkdown_base {}
+//#endregion
+//#region src/runtime.d.ts
 /**
  * Every service the MCP runtime provides to the tool handlers.
  *
@@ -12,26 +136,21 @@ import "zod";
  * `FileSystem.FileSystem | Path.Path` are here so `repos_inspect`'s
  * `gitmodules` mode can read `.gitmodules` through the ambient service
  * (mirroring `Repos.ReposDrift.check`) rather than a bare `node:fs` import —
- * `makeSilkRuntimeLayer` passes both through onto its own output via an
- * `Effect.context` identity layer, so they survive `bin.ts`'s
+ * {@link makeSilkRuntimeLayer} passes both through onto its own output via an
+ * `Effect.context` identity layer, so they survive `main.ts`'s
  * `Layer.provide(NodeServices.layer)` instead of being fully discharged by
  * it.
+ *
+ * @public
  */
 type McpServices = SilkWorkspaceAnalyzer | WorkspaceRoot | Turbo.TurboInspector | Changesets.BranchAnalyzer | Changesets.ConfigInspector | Changesets.ReleasePlanner | Changesets.DepsRegen | Repos.ReposManager | Repos.ReposConfigStore | Repos.ReposDrift | FileSystem.FileSystem | Path.Path;
-/** The long-lived runtime and the project working directory. */
-interface McpContext {
-  readonly runtime: ManagedRuntime.ManagedRuntime<McpServices, never>;
-  readonly cwd: string;
-}
-//#endregion
-//#region src/runtime.d.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`,
  * `Repos.ReposConfigStore`, and `Repos.ReposDrift`; requires `ChildProcessSpawner` + `FileSystem`
- * + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
+ * + `Path` from the host's platform layer (`NodeServices.layer` in main.ts).
  *
  * @remarks
  * The kit graph (`Workspaces.layerWithGitAndConfigDependenciesSubprocess`)
@@ -51,8 +170,566 @@ interface McpContext {
 export 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. */
-export declare function startMcpServer(ctx: McpContext): Promise<void>;
+/**
+ * Everything {@link ServerLayer} still needs from the platform: the three
+ * services `makeSilkRuntimeLayer` requires, plus `Stdio`, which
+ * `McpServer.layerStdio` itself requires (`McpServer.ts:1217-1225`).
+ * `NodeServices.layer` supplies all four in `main.ts`; tests swap `Stdio`
+ * for `Stdio.layerTest`.
+ *
+ * @public
+ */
+type PlatformServices = FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | Stdio.Stdio;
+/**
+ * The whole server as one layer: the ten-tool toolkit, the silk-effects
+ * runtime discharging its dependencies, over `McpServer.layerStdio`.
+ *
+ * `protocols` lists the newest two adapters, newest first — see gotcha 2 in
+ * the module remarks. `Cause.IllegalArgumentError` in `layerStdio`'s error
+ * channel is `orDie`d: `protocols` is a static two-element literal, so it is
+ * an implementer-time defect, not a runtime condition.
+ *
+ * @public
+ */
+export declare const ServerLayer: (cwd: string) => Layer.Layer<never, never, PlatformServices>;
+//#endregion
+//#region src/tools/biome-check.d.ts
+/**
+ * The `biome_check` tool value. Mutating when `write`/`unsafe` is set, so it is
+ * annotated non-read-only and non-idempotent; `dependencies` is empty because
+ * the handler shells out directly and yields no service.
+ */
+declare const biomeCheckTool: Tool.Tool<"biome_check", {
+  readonly parameters: Schema.Struct<{
+    readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly mode: Schema.optionalKey<Schema.Literals<readonly ["check", "lint"]>>;
+    readonly write: Schema.optionalKey<Schema.Boolean>;
+    readonly unsafe: Schema.optionalKey<Schema.Boolean>;
+    readonly strict: Schema.optionalKey<Schema.Boolean>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Struct<{
+    readonly summary: Schema.Struct<{
+      readonly errors: Schema.Number;
+      readonly warnings: Schema.Number;
+      /** Count of project-level warnings reported as errors because `strict` was set. */
+      readonly upgradedWarnings: Schema.optional<Schema.Number>;
+    }>;
+    readonly diagnostics: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly line: Schema.Number;
+      readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>;
+      readonly rule: Schema.String;
+      readonly message: Schema.String;
+      /** Present only when `strict` upgraded this diagnostic; holds the project-configured severity. */
+      readonly originalSeverity: Schema.optional<Schema.Literals<readonly ["error", "warning", "info"]>>;
+    }>>;
+    readonly wrote: Schema.Boolean;
+    readonly guidance: Schema.String;
+  }>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, never>;
+//#endregion
+//#region src/tools/changeset-deps-detect.d.ts
+/** The `changeset_deps_detect` tool value. */
+declare const changesetDepsDetectTool: Tool.Tool<"changeset_deps_detect", {
+  readonly parameters: Schema.Struct<{
+    readonly base: Schema.optionalKey<Schema.String>;
+    readonly package: Schema.optionalKey<Schema.String>;
+    readonly packages: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly exclude: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Struct<{
+    readonly root: Schema.String;
+    readonly packages: Schema.$Array<Schema.Struct<{
+      readonly package: Schema.String;
+      readonly relativePath: Schema.String;
+      readonly rows: Schema.$Array<Schema.Struct<{
+        readonly dependency: Schema.String;
+        readonly type: Schema.Literals<readonly ["dependency", "devDependency", "peerDependency", "optionalDependency", "workspace", "config", "runtime", "packageManager"]>;
+        readonly action: Schema.Literals<readonly ["added", "updated", "removed"]>;
+        readonly from: Schema.String;
+        readonly to: Schema.String;
+      }>>;
+    }>>;
+    readonly coexisting: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly packages: Schema.$Array<Schema.String>;
+    }>>;
+  }>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, Changesets.DepsRegen | WorkspaceRoot>;
+//#endregion
+//#region src/tools/changeset-deps-regen.d.ts
+/** The `changeset_deps_regen` tool value. Mutating: not read-only, not idempotent. */
+declare const changesetDepsRegenTool: Tool.Tool<"changeset_deps_regen", {
+  readonly parameters: Schema.Struct<{
+    readonly base: Schema.optionalKey<Schema.String>;
+    readonly package: Schema.optionalKey<Schema.String>;
+    readonly packages: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly exclude: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly dryRun: Schema.optionalKey<Schema.Boolean>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Struct<{
+    readonly root: Schema.String;
+    readonly deleted: Schema.$Array<Schema.String>;
+    readonly written: Schema.$Array<Schema.String>;
+    readonly skippedMixed: Schema.$Array<Schema.String>;
+    readonly coexisting: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly packages: Schema.$Array<Schema.String>;
+    }>>;
+    readonly dryRun: Schema.Boolean;
+  }>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, Changesets.DepsRegen | WorkspaceRoot>;
+//#endregion
+//#region src/tools/changeset-inspect.d.ts
+/** The `changeset_inspect` tool value. */
+declare const changesetInspectTool: Tool.Tool<"changeset_inspect", {
+  readonly parameters: Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["branch", "config", "classify"]>;
+    readonly base: Schema.optionalKey<Schema.String>;
+    readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"branch">;
+    readonly result: Schema.Struct<{
+      readonly baseBranch: Schema.String;
+      readonly mergeBaseSha: Schema.String;
+      readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly status: Schema.Literals<readonly ["added", "modified", "deleted", "renamed", "copied", "typechange", "unmerged", "unknown"]>;
+        readonly package: Schema.NullOr<Schema.String>;
+        readonly reason: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Struct<{
+          readonly kind: Schema.Literal<"additionalScope">;
+          readonly glob: Schema.String;
+        }>, Schema.Struct<{
+          readonly kind: Schema.Literal<"versionFile">;
+          readonly glob: Schema.String;
+        }>, Schema.Struct<{
+          readonly kind: Schema.Literal<"unmappedHint">;
+          readonly hint: Schema.String;
+        }>, Schema.Null]>;
+      }>>;
+      readonly packagesAffected: Schema.$Array<Schema.String>;
+      readonly unmappedFiles: Schema.$Array<Schema.String>;
+    }>;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"config">;
+    readonly result: Schema.Struct<{
+      readonly configPath: Schema.String;
+      readonly projectDir: Schema.String;
+      readonly changelog: Schema.NullOr<Schema.String>;
+      readonly baseBranch: Schema.String;
+      readonly access: Schema.Literals<readonly ["public", "restricted"]>;
+      readonly ignore: Schema.$Array<Schema.String>;
+      readonly packages: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly workspaceDir: Schema.String;
+        readonly version: Schema.optional<Schema.String>;
+        readonly additionalScopes: Schema.$Array<Schema.String>;
+        readonly additionalScopeFiles: Schema.$Array<Schema.String>;
+        readonly versionFiles: Schema.$Array<Schema.Struct<{
+          readonly glob: Schema.String;
+          readonly paths: Schema.$Array<Schema.String>;
+          readonly matchedFiles: Schema.$Array<Schema.String>;
+        }>>;
+      }>>;
+      readonly legacyVersionFilesUsed: Schema.Boolean;
+    }>;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"classify">;
+    readonly result: Schema.$Array<Schema.Struct<{
+      readonly path: Schema.String;
+      readonly package: Schema.NullOr<Schema.String>;
+      readonly reason: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Struct<{
+        readonly kind: Schema.Literal<"additionalScope">;
+        readonly glob: Schema.String;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"versionFile">;
+        readonly glob: Schema.String;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"unmappedHint">;
+        readonly hint: Schema.String;
+      }>, Schema.Null]>;
+    }>>;
+  }>]>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, Changesets.BranchAnalyzer | Changesets.ConfigInspector | WorkspaceRoot>;
+//#endregion
+//#region src/tools/changeset-preview.d.ts
+/** The `changeset_preview` tool value. */
+declare const changesetPreviewTool: Tool.Tool<"changeset_preview", {
+  readonly parameters: Schema.Struct<{
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Struct<{
+    readonly preMode: Schema.NullOr<Schema.Literals<readonly ["exit", "pre"]>>;
+    readonly releases: Schema.$Array<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly type: Schema.Literals<readonly ["major", "minor", "patch"]>;
+      readonly oldVersion: Schema.String;
+      readonly newVersion: Schema.String;
+      readonly changesetIds: Schema.$Array<Schema.String>;
+      readonly changelogEntry: Schema.String;
+    }>>;
+    readonly changesets: Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly summary: Schema.String;
+      readonly releases: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly type: Schema.Literals<readonly ["major", "minor", "patch"]>;
+      }>>;
+    }>>;
+  }>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, Changesets.ReleasePlanner | WorkspaceRoot>;
+//#endregion
+//#region src/tools/changeset-validate.d.ts
+/** The `changeset_validate` tool value. */
+declare const changesetValidateTool: Tool.Tool<"changeset_validate", {
+  readonly parameters: Schema.Struct<{
+    readonly dir: Schema.optionalKey<Schema.String>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Struct<{
+    readonly dir: Schema.String;
+    readonly ok: Schema.Boolean;
+    readonly errorCount: Schema.Number;
+    readonly messages: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly rule: Schema.String;
+      readonly line: Schema.Number;
+      readonly column: Schema.Number;
+      readonly message: Schema.String;
+    }>>;
+  }>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, WorkspaceRoot>;
+//#endregion
+//#region src/tools/repos-inspect.d.ts
+/** The `repos_inspect` tool value. */
+declare const reposInspectTool: Tool.Tool<"repos_inspect", {
+  readonly parameters: Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["status", "config", "drift", "gitmodules"]>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"status">;
+    readonly result: Schema.Struct<{
+      readonly repos: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly ref: Schema.String;
+        readonly purpose: Schema.String;
+        readonly present: Schema.Boolean;
+        readonly stagedCommit: Schema.optionalKey<Schema.String>;
+        readonly committedCommit: Schema.optionalKey<Schema.String>;
+        readonly checkedOutCommit: Schema.optionalKey<Schema.String>;
+        readonly dirty: Schema.Boolean;
+        readonly staleNoteIds: Schema.$Array<Schema.String>;
+      }>>;
+      readonly clean: Schema.Boolean;
+    }>;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"config">;
+    readonly result: Schema.Struct<{
+      readonly repos: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly url: Schema.String;
+        readonly ref: Schema.String;
+        readonly purpose: Schema.String;
+        readonly sparse: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly orientation: Schema.optional<Schema.Struct<{
+          readonly layout: Schema.optional<Schema.String>;
+          readonly keyPaths: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+          readonly startHere: Schema.optional<Schema.String>;
+        }>>;
+        readonly notes: Schema.optional<Schema.$Array<Schema.Struct<{
+          readonly id: Schema.String;
+          readonly date: Schema.String;
+          readonly ref: Schema.String;
+          readonly note: Schema.String;
+        }>>>;
+      }>>;
+    }>;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"drift">;
+    readonly report: typeof Repos.ReposDriftReport;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"gitmodules">;
+    readonly entries: Schema.$Array<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly path: Schema.String;
+      readonly url: Schema.String;
+      readonly branch: Schema.optionalKey<Schema.String>;
+      readonly shallow: Schema.optionalKey<Schema.Boolean>;
+      readonly update: Schema.optionalKey<Schema.String>;
+      readonly ignore: Schema.optionalKey<Schema.Literals<readonly ["all", "dirty", "untracked", "none"]>>;
+      readonly fetchRecurseSubmodules: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Literal<"on-demand">]>>;
+    }>>;
+    readonly parseError: Schema.optionalKey<Schema.String>;
+  }>]>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, FileSystem.FileSystem | Path.Path | Repos.ReposConfigStore | Repos.ReposDrift | Repos.ReposManager | WorkspaceRoot>;
+//#endregion
+//#region src/tools/repos-manage.d.ts
+/** The `repos_manage` tool value. Mutating: not read-only, not idempotent. */
+declare const reposManageTool: Tool.Tool<"repos_manage", {
+  readonly parameters: Schema.Struct<{
+    readonly action: Schema.Literals<readonly ["sync", "pin", "add", "note", "remove", "rename", "restore", "deregister"]>;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly newName: Schema.optionalKey<Schema.String>;
+    readonly ref: Schema.optionalKey<Schema.String>;
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly purpose: Schema.optionalKey<Schema.String>;
+    readonly sparse: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly orientation: Schema.optionalKey<Schema.Struct<{
+      readonly layout: Schema.optional<Schema.String>;
+      readonly keyPaths: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+      readonly startHere: Schema.optional<Schema.String>;
+    }>>;
+    readonly op: Schema.optionalKey<Schema.Literals<readonly ["add", "remove", "promote"]>>;
+    readonly note: Schema.optionalKey<Schema.String>;
+    readonly id: Schema.optionalKey<Schema.String>;
+    readonly into: Schema.optionalKey<Schema.Literals<readonly ["layout", "startHere"]>>;
+    readonly names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly section: Schema.optionalKey<Schema.String>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Union<readonly [Schema.Struct<{
+    readonly action: Schema.Literal<"sync">;
+    readonly result: Schema.Struct<{
+      readonly initialized: Schema.$Array<Schema.String>;
+      readonly sparseApplied: Schema.$Array<Schema.String>;
+      readonly upToDate: Schema.$Array<Schema.String>;
+      readonly clearedLocks: Schema.$Array<Schema.String>;
+      readonly urlSynced: Schema.$Array<Schema.String>;
+      readonly registered: Schema.$Array<Schema.String>;
+      readonly boundaryMarked: Schema.$Array<Schema.String>;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"pin">;
+    readonly result: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly ref: Schema.String;
+      readonly oldCommit: Schema.NullOr<Schema.String>;
+      readonly newCommit: Schema.String;
+      readonly commitMessage: Schema.String;
+      readonly staleNoteIds: Schema.$Array<Schema.String>;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"add">;
+    readonly result: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly ref: Schema.String;
+      readonly path: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"note">;
+    readonly result: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly op: Schema.Literals<readonly ["add", "remove", "promote"]>;
+      readonly id: Schema.String;
+      readonly noteCount: Schema.Number;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"remove">;
+    readonly result: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly path: Schema.String;
+      readonly commitMessage: Schema.String;
+      readonly removedNotes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly date: Schema.String;
+        readonly ref: Schema.String;
+        readonly note: Schema.String;
+      }>>;
+      readonly removedEntry: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly ref: Schema.String;
+        readonly purpose: Schema.String;
+        readonly sparse: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly orientation: Schema.optional<Schema.Struct<{
+          readonly layout: Schema.optional<Schema.String>;
+          readonly keyPaths: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+          readonly startHere: Schema.optional<Schema.String>;
+        }>>;
+        readonly notes: Schema.optional<Schema.$Array<Schema.Struct<{
+          readonly id: Schema.String;
+          readonly date: Schema.String;
+          readonly ref: Schema.String;
+          readonly note: Schema.String;
+        }>>>;
+      }>;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"rename">;
+    readonly result: Schema.Struct<{
+      readonly oldName: Schema.String;
+      readonly newName: Schema.String;
+      readonly path: Schema.String;
+      readonly commitMessage: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"restore">;
+    readonly result: Schema.Struct<{
+      readonly restored: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly commit: Schema.String;
+      }>>;
+      readonly skippedClean: Schema.$Array<Schema.String>;
+      readonly stillDirty: Schema.$Array<Schema.String>;
+    }>;
+  }>, Schema.Struct<{
+    readonly action: Schema.Literal<"deregister">;
+    readonly result: Schema.Struct<{
+      readonly section: Schema.String;
+      readonly removedKeys: Schema.$Array<Schema.String>;
+    }>;
+  }>]>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, Repos.ReposManager | WorkspaceRoot>;
+//#endregion
+//#region src/tools/turbo-inspect.d.ts
+/** The `turbo_inspect` tool value. */
+declare const turboInspectTool: Tool.Tool<"turbo_inspect", {
+  readonly parameters: Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["cache", "graph", "affected"]>;
+    readonly task: Schema.optionalKey<Schema.String>;
+    readonly base: Schema.optionalKey<Schema.String>;
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"cache">;
+    readonly result: Schema.Struct<{
+      readonly task: Schema.String;
+      readonly totalTasks: Schema.Number;
+      readonly hits: Schema.Number;
+      readonly misses: Schema.Number;
+      readonly statuses: Schema.$Array<Schema.Struct<{
+        readonly package: Schema.String;
+        readonly taskId: Schema.String;
+        readonly hash: Schema.String;
+        readonly status: Schema.Literals<readonly ["HIT", "MISS"]>;
+        readonly timeSaved: Schema.Number;
+      }>>;
+      readonly explanations: Schema.$Array<Schema.Struct<{
+        readonly package: Schema.String;
+        readonly taskId: Schema.String;
+        readonly hash: Schema.String;
+        readonly inputFileCount: Schema.Number;
+        readonly hashedEnvVars: Schema.$Array<Schema.String>;
+        readonly externalDependenciesHash: Schema.String;
+        readonly dependsOn: Schema.$Array<Schema.String>;
+      }>>;
+      readonly global: Schema.Struct<{
+        readonly rootKey: Schema.String;
+        readonly globalFileCount: Schema.Number;
+        readonly externalDependenciesHash: Schema.String;
+        readonly internalDependenciesHash: Schema.String;
+        readonly globalEnvVars: Schema.$Array<Schema.String>;
+      }>;
+    }>;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"graph">;
+    readonly result: Schema.Struct<{
+      readonly task: Schema.optional<Schema.String>;
+      readonly nodeCount: Schema.Number;
+      readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly taskId: Schema.String;
+        readonly package: Schema.String;
+        readonly dependsOn: Schema.$Array<Schema.String>;
+      }>>;
+      readonly criticalPath: Schema.$Array<Schema.String>;
+    }>;
+  }>, Schema.Struct<{
+    readonly mode: Schema.Literal<"affected">;
+    readonly result: Schema.Struct<{
+      readonly base: Schema.String;
+      readonly packages: Schema.$Array<Schema.String>;
+      readonly dependents: Schema.$Array<Schema.String>;
+    }>;
+  }>]>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, Turbo.TurboInspector | WorkspaceRoot>;
+//#endregion
+//#region src/tools/workspace-info.d.ts
+/**
+ * The `workspace_info` tool value. `dependencies` names the two services the
+ * handler yields so `Tool.HandlerServices` carries them (without it the
+ * handler record fails against `Toolkit.HandlersFrom`).
+ */
+declare const workspaceInfoTool: Tool.Tool<"workspace_info", {
+  readonly parameters: Schema.Struct<{
+    readonly cwd: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly success: Schema.Struct<{
+    readonly root: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["node", "bun"]>;
+    readonly packageManager: Schema.Struct<{
+      readonly type: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun"]>;
+      readonly version: Schema.optional<Schema.String>;
+    }>;
+    readonly workspaceCount: Schema.Number;
+    readonly workspaces: Schema.$Array<Schema.Struct<{
+      readonly name: Schema.String;
+      /** Absent when the manifest declares no `version` — legal for a private package or root. */
+      readonly version: Schema.optional<Schema.String>;
+      readonly path: Schema.String;
+      readonly root: Schema.Boolean;
+      readonly publishable: Schema.Boolean;
+      readonly targets: Schema.$Array<Schema.String>;
+      readonly versioned: Schema.Boolean;
+      readonly tagged: Schema.Boolean;
+      readonly released: Schema.Boolean;
+      readonly linked: Schema.$Array<Schema.String>;
+      readonly fixed: Schema.$Array<Schema.String>;
+    }>>;
+  }>;
+  readonly failure: Schema.Union<readonly [typeof WorkspaceNotFound, typeof InvalidArgument, typeof EngineError, typeof BiomeUnavailable, typeof BiomeFailed]>;
+  readonly failureMode: "error";
+}, SilkWorkspaceAnalyzer | WorkspaceRoot>;
+//#endregion
+//#region src/toolkit.d.ts
+/**
+ * The served tool record, keyed by wire name. Spelled out through the
+ * exported `Toolkit.ToolsByName` (rather than inferred through
+ * `Toolkit.make`) so the exported toolkit and handler layer have nameable
+ * declaration types — inference reaches into silk-effects' unexported
+ * `*Shape` interfaces and fails declaration emit (TS4023).
+ *
+ * @public
+ */
+type SilkTools = Toolkit.ToolsByName<readonly [typeof workspaceInfoTool, typeof turboInspectTool, typeof changesetInspectTool, typeof changesetValidateTool, typeof changesetDepsDetectTool, typeof changesetPreviewTool, typeof changesetDepsRegenTool, typeof reposInspectTool, typeof reposManageTool, typeof biomeCheckTool]>;
+/**
+ * The ten savvy-mcp tools — seven read-only, three mutating (`biome_check`
+ * with `write`/`unsafe`, `changeset_deps_regen`, `repos_manage`) — in the
+ * order `tools/list` serves them.
+ *
+ * @public
+ */
+export declare const SilkToolkit: Toolkit.Toolkit<SilkTools>;
+/**
+ * The handler layer. `cwd` — the project directory `main.ts` resolved once at
+ * startup — is closed over as every handler's fallback when a call omits its
+ * own `cwd`; the handlers' declared service dependencies are discharged by
+ * `makeSilkRuntimeLayer(cwd)` in `server.ts`.
+ *
+ * @public
+ */
+export declare const ToolsLayer: (cwd: string) => Layer.Layer<Tool.HandlersFor<SilkTools>>;
 //#endregion
 //#region src/version.d.ts
 /**
@@ -62,7 +739,7 @@ export declare function startMcpServer(ctx: McpContext): Promise<void>;
  *
  * @packageDocumentation
  */
-export declare const CURRENT_MCP_VERSION = "0.0.0";
+export declare const CURRENT_MCP_VERSION: any;
 //#endregion
-export type { McpContext, McpServices };
+export type { McpServices, PlatformServices, SilkTools };
 //# sourceMappingURL=index.d.ts.map