@savvy-web/mcp 2.1.0 → 2.2.0

package/README.md

@@ -49,8 +49,8 @@ npx @modelcontextprotocol/inspector savvy-mcp .
 - `changeset_deps_detect` — read-only preview of the cumulative dependency diff (merge-base to working tree): one entry per affected workspace package with its resolved dependency-table rows, `catalog:`/`workspace:` specifiers resolved to concrete versions. It never writes a changeset. Backed by `silk-effects`' `Changesets.DepsRegen.plan`.
 - `changeset_deps_regen` — regenerates pure-dependency changesets: deletes stale ones and writes fresh single-package, patch-bump changesets from the cumulative dependency diff. Mutating unless `dryRun` is set, in which case it reports what it would delete and write without touching the filesystem. Backed by `silk-effects`' `Changesets.DepsRegen`.
 - `biome_check` — run Biome over a path and get structured diagnostics back: `mode=check` (lint, format and organize-imports) or `mode=lint`. Unlike most of the other tools it can mutate — pass `write` for safe fixes or `unsafe` for unsafe ones (both git-reversible) — so it returns the same diagnostics the Biome LSP surfaces for files you have edited.
-- `repos_inspect` — read-only inspection of vendored repositories: `mode=status` reports per-repo presence, the gitlink commit, working-tree dirtiness, and stale note ids; `mode=config` surfaces the validated `.repos/config.json` manifest and its entries. Returns markdown-escaped output since vendored-repo content is untrusted input. Backed by the same `silk-effects` `Repos` services the `savvy` CLI uses.
-- `repos_manage` — manages vendored repositories (mutating counterpart to repos_inspect): `action=sync` initializes any missing submodules (`git submodule update --init --depth 1`), applies sparse-checkout from the manifest, and clears stale git locks; `action=pin` fetches and checks out the new ref, staging the updated gitlink and manifest; `action=add` adds a new repo entry; `action=note` appends a short note to a repo. Pin and add stage git changes for the caller to commit. `sync`, `pin` and `add` unlock the vendored tree for the duration of their git work and leave it read-only again afterwards (files `0444`, directories `0555`), so an agent that hits `EACCES` writing into `.repos/` should route the change through this tool rather than `chmod`. Backed by the same `silk-effects` `Repos` services the `savvy` CLI uses.
+- `repos_inspect` — read-only inspection of vendored repositories: `mode=status` reports per-repo presence, the gitlink commit, working-tree dirtiness, and stale note ids; `mode=config` surfaces the validated `.repos/config.json` manifest and its entries; `mode=drift` reconciles the manifest, `.gitmodules`, the worktree, and `git submodule status`, reporting any mismatch as a typed drift kind; `mode=gitmodules` lists the parsed `.gitmodules` entries. Returns markdown-escaped output since vendored-repo content is untrusted input. Backed by the same `silk-effects` `Repos` services the `savvy` CLI uses.
+- `repos_manage` — manages vendored repositories (mutating counterpart to repos_inspect): `action=sync` initializes any missing submodules (`git submodule update --init --depth 1`), applies sparse-checkout from the manifest, and clears stale git locks; `action=pin` fetches and checks out the new ref, staging the updated gitlink and manifest; `action=add` adds a new repo entry; `action=note` appends a short note to a repo; `action=remove` unvendors an entry; `action=rename` renames one in place; `action=restore` hard-resets one or more dirty checkouts back to their pinned commit. Pin, add, remove and rename stage git changes for the caller to commit; restore only resets the submodule's own working tree to its already-staged or already-committed gitlink commit, so there is nothing new to stage. `sync`, `pin`, `add`, `remove`, `rename` and `restore` unlock the vendored tree for the duration of their git work and leave it read-only again afterwards (files `0444`, directories `0555` — an executable file locks at `0555` instead, unlocking back to `0755` rather than losing its executable bit), so an agent that hits `EACCES` writing into `.repos/` should route the change through this tool rather than `chmod`. Backed by the same `silk-effects` `Repos` services the `savvy` CLI uses.
 
 ## License
 

package/index.d.ts

@@ -3,9 +3,21 @@ import { Changesets, Repos, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk
 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
-/** 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;
+/**
+ * Every service the MCP runtime provides to the tool handlers.
+ *
+ * @remarks
+ * `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
+ * `Layer.provide(NodeServices.layer)` instead of being fully discharged by
+ * it.
+ */
+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>;
@@ -18,7 +30,7 @@ interface McpContext {
  * `SilkWorkspaceAnalyzer`, `WorkspaceRoot`, `Turbo.TurboInspector`,
  * `Changesets.BranchAnalyzer`, `Changesets.ConfigInspector`,
  * `Changesets.ReleasePlanner`, `Changesets.DepsRegen`, `Repos.ReposManager`,
- * and `Repos.ReposConfigStore`; requires `ChildProcessSpawner` + `FileSystem`
+ * `Repos.ReposConfigStore`, and `Repos.ReposDrift`; requires `ChildProcessSpawner` + `FileSystem`
  * + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
  *
  * @remarks

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "2.1.0",
+	"version": "2.2.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",
@@ -33,9 +33,10 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-beta.101",
 		"@effected/commands": "^0.3.1",
-		"@effected/workspaces": "^0.10.0",
+		"@effected/git": "^0.6.0",
+		"@effected/workspaces": "^0.10.2",
 		"@modelcontextprotocol/sdk": "^1.29.0",
-		"@savvy-web/silk-effects": "5.4.0",
+		"@savvy-web/silk-effects": "5.5.0",
 		"effect": "4.0.0-beta.101",
 		"zod": "^4.4.3"
 	}

package/runtime.js

@@ -1,7 +1,7 @@
 import { ToolDiscovery } from "@effected/commands";
 import { Workspaces } from "@effected/workspaces";
 import { ChangesetConfig, ChangesetConfigReader, Changesets, Repos, SilkPublishability, SilkWorkspaceAnalyzer, Turbo } from "@savvy-web/silk-effects";
-import { Layer } from "effect";
+import { Effect, Layer } from "effect";
 
 //#region src/runtime.ts
 /**
@@ -21,7 +21,7 @@ import { Layer } from "effect";
 * `SilkWorkspaceAnalyzer`, `WorkspaceRoot`, `Turbo.TurboInspector`,
 * `Changesets.BranchAnalyzer`, `Changesets.ConfigInspector`,
 * `Changesets.ReleasePlanner`, `Changesets.DepsRegen`, `Repos.ReposManager`,
-* and `Repos.ReposConfigStore`; requires `ChildProcessSpawner` + `FileSystem`
+* `Repos.ReposConfigStore`, and `Repos.ReposDrift`; requires `ChildProcessSpawner` + `FileSystem`
 * + `Path` from the host's platform layer (`NodeServices.layer` in bin.ts).
 *
 * @remarks
@@ -65,9 +65,14 @@ const makeSilkRuntimeLayer = (cwd) => {
 	* Same reference — one store instance. `ReposLockdown.layer` needs only the
 	* platform services, which flow up from the outer `NodeServices.layer`
 	* provision like `ReposManager`'s own `FileSystem`/`Path` requirement does.
+	* `ReposDrift.layer` is read-only (no `ReposLockdown` interaction) and
+	* requires only `ReposConfigStore | Git | FileSystem | Path`; `Git` comes
+	* from `kitGraph` below via the same one-reference discipline, and
+	* `repos_inspect`'s drift mode resolves it directly.
 	*/
-	const repos = Layer.mergeAll(Repos.ReposConfigStore.layer, Repos.ReposManager.layer.pipe(Layer.provide(Repos.ReposConfigStore.layer), Layer.provide(Repos.ReposLockdown.layer)));
-	return Layer.mergeAll(SilkWorkspaceAnalyzer.layer.pipe(Layer.provide(analyzerDeps)), Turbo.TurboInspector.layer.pipe(Layer.provide(toolDiscovery)), inspectorAndAnalyzer, depsRegen, repos).pipe(Layer.provideMerge(kitGraph));
+	const repos = Layer.mergeAll(Repos.ReposConfigStore.layer, Repos.ReposManager.layer.pipe(Layer.provide(Repos.ReposConfigStore.layer), Layer.provide(Repos.ReposLockdown.layer)), Repos.ReposDrift.layer.pipe(Layer.provide(Repos.ReposConfigStore.layer)));
+	const platformPassthrough = Layer.effectContext(Effect.context());
+	return Layer.mergeAll(SilkWorkspaceAnalyzer.layer.pipe(Layer.provide(analyzerDeps)), Turbo.TurboInspector.layer.pipe(Layer.provide(toolDiscovery)), inspectorAndAnalyzer, depsRegen, repos, platformPassthrough).pipe(Layer.provideMerge(kitGraph));
 };
 
 //#endregion

package/server.js

@@ -22,6 +22,17 @@ import { z } from "zod";
 *
 * @packageDocumentation
 */
+/**
+* The `repos_inspect` wire-level `mode` enum. Exported so tests can assert
+* the boundary rejects an unknown mode without duplicating the enum's
+* member list.
+*/
+const ReposInspectModeSchema = z.enum([
+	"status",
+	"config",
+	"drift",
+	"gitmodules"
+]).describe("status = drift report; config = the full agent brief; drift = four-authority submodule reconciliation; gitmodules = decoded .gitmodules sections.");
 /** Wrap a markdown string + structured object in the dual-channel tool result. */
 const structuredResult = (text, structured) => ({
 	content: [{
@@ -145,9 +156,9 @@ function buildServer(ctx) {
 	});
 	server.registerTool("repos_inspect", {
 		title: "Inspect vendored repos",
-		description: "Read-only: drift report or parsed .repos/config.json manifest with orientation and notes.",
+		description: "Read-only: drift report or parsed .repos/config.json manifest with orientation and notes. mode=status is the per-repo drift summary from ReposManager (present/dirty/commit); mode=config is the parsed manifest; mode=drift reconciles all four submodule authorities (manifest, .gitmodules, worktree, git submodule status) and reports every disagreement; mode=gitmodules decodes the raw .gitmodules file's submodule sections.",
 		inputSchema: {
-			mode: z.enum(["status", "config"]).describe("status = drift report; config = the full agent brief."),
+			mode: ReposInspectModeSchema,
 			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
 		},
 		outputSchema: effectToZodSchema(ReposInspectResult),
@@ -159,15 +170,19 @@ function buildServer(ctx) {
 	});
 	server.registerTool("repos_manage", {
 		title: "Manage vendored repos",
-		description: "Mutating: sync (initialize/reconcile submodules per the manifest), pin (re-pin a repo to a new ref), add (vendor a new repo), or note (add/remove/promote an agent note). Pass action plus the fields that action needs: pin needs name+ref; add needs url+ref+purpose (name/sparse optional); note needs name+op, plus note (op=add), id (op=remove), or id+into (op=promote). A decode failure names the missing field. The pin result's markdown surfaces commitMessage and staleNoteIds — review and commit after pinning.",
+		description: "Mutating: sync (initialize/reconcile submodules per the manifest), pin (re-pin a repo to a new ref), add (vendor a new repo), note (add/remove/promote an agent note), remove (unvendor a repo), rename (rename a vendored repo's manifest key and worktree), or restore (hard-reset a repo's worktree back to its pinned gitlink commit and re-apply sparse paths — DESTRUCTIVE to uncommitted worktree edits; never run implicitly). Pass action plus the fields that action needs: pin needs name+ref; add needs url+ref+purpose (name/sparse optional); note needs name+op, plus note (op=add), id (op=remove), or id+into (op=promote); remove needs name; rename needs name (the old name) + newName; restore takes an optional names list — omitted, it restores every dirty repo and reports the clean ones as skipped; given, it restores exactly those repos even if already clean. A decode failure names the missing field. The pin result's markdown surfaces commitMessage and staleNoteIds — review and commit after pinning. The remove result's markdown surfaces commitMessage and removedNotes — promote any durable notes elsewhere, then review and commit. The rename result's markdown surfaces commitMessage — review and commit after renaming. The restore result's markdown names exactly what was discarded.",
 		inputSchema: {
 			action: z.enum([
 				"sync",
 				"pin",
 				"add",
-				"note"
+				"note",
+				"remove",
+				"rename",
+				"restore"
 			]).describe("Which mutation to perform."),
-			name: z.optional(z.string()).describe("Repo name (pin, note; optional override for add)."),
+			name: z.optional(z.string()).describe("Repo name (pin, note, remove, rename; optional override for add)."),
+			newName: z.optional(z.string()).describe("New repo name (rename)."),
 			ref: z.optional(z.string()).describe("Git ref to pin/vendor to (pin, add)."),
 			url: z.optional(z.string()).describe("Repo URL to vendor (add)."),
 			purpose: z.optional(z.string()).describe("One-line purpose for the manifest (add)."),
@@ -180,6 +195,7 @@ function buildServer(ctx) {
 			note: z.optional(z.string()).describe("Note text (note, op=add)."),
 			id: z.optional(z.string()).describe("Note id (note, op=remove|promote)."),
 			into: z.optional(z.enum(["layout", "startHere"])).describe("Orientation target (note, op=promote)."),
+			names: z.optional(z.array(z.string())).describe("Repo names to restore (restore); omitted restores every dirty repo."),
 			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
 		},
 		outputSchema: effectToZodSchema(ReposManageResult),
@@ -218,4 +234,4 @@ async function startMcpServer(ctx) {
 }
 
 //#endregion
-export { buildServer, startMcpServer };
+export { ReposInspectModeSchema, buildServer, startMcpServer };

package/tools/repos-inspect.js

@@ -1,9 +1,34 @@
 import { mdInline } from "./md-inline.js";
 import { WorkspaceRoot } from "@effected/workspaces";
 import { Repos } from "@savvy-web/silk-effects";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, FileSystem, Option, Path, Result, Schema, SchemaGetter } from "effect";
+import { Gitmodules } from "@effected/git";
 
 //#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
+*/
+/** One `.gitmodules` submodule section, decoded into typed fields. */
+const GitmodulesEntrySchema = Schema.Struct({
+	name: Schema.String,
+	path: Schema.String,
+	url: Schema.String,
+	branch: Schema.optionalKey(Schema.String),
+	shallow: Schema.optionalKey(Schema.Boolean),
+	update: Schema.optionalKey(Schema.String),
+	ignore: Schema.optionalKey(Schema.Literals([
+		"all",
+		"dirty",
+		"untracked",
+		"none"
+	])),
+	fetchRecurseSubmodules: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Literal("on-demand")]))
+}).annotate({ identifier: "GitmodulesEntry" });
 /** Status-report variant. */
 const ReposStatusResult = Schema.Struct({
 	mode: Schema.Literal("status"),
@@ -14,11 +39,27 @@ const ReposConfigResult = Schema.Struct({
 	mode: Schema.Literal("config"),
 	result: Repos.ReposManifestFile
 }).annotate({ identifier: "ReposConfigResult" });
+/** Four-authority drift-reconciliation variant. */
+const ReposDriftResult = Schema.Struct({
+	mode: Schema.Literal("drift"),
+	report: Repos.ReposDriftReport
+}).annotate({ identifier: "ReposDriftResult" });
+/** Raw `.gitmodules` variant: the decoded submodule sections, or a parse error. */
+const ReposGitmodulesResult = Schema.Struct({
+	mode: Schema.Literal("gitmodules"),
+	entries: Schema.Array(GitmodulesEntrySchema),
+	parseError: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "ReposGitmodulesResult" });
 /** The `repos_inspect` tool result — a discriminated union keyed by `mode`. */
-const ReposInspectResult = Schema.Union([ReposStatusResult, ReposConfigResult]).annotate({
+const ReposInspectResult = Schema.Union([
+	ReposStatusResult,
+	ReposConfigResult,
+	ReposDriftResult,
+	ReposGitmodulesResult
+]).annotate({
 	identifier: "ReposInspectResult",
 	title: "repos_inspect result",
-	description: "Drift report (status) or the parsed manifest with purposes, orientation, and notes (config)."
+	description: "Drift report (status), the parsed manifest (config), the four-authority reconciliation report (drift), or the decoded .gitmodules sections (gitmodules)."
 });
 /** Render the structured result as a markdown transcript. */
 const renderMarkdown = (data) => {
@@ -33,7 +74,7 @@ const renderMarkdown = (data) => {
 				`## Repos`
 			];
 			for (const entry of r.repos) {
-				lines.push(`### ${mdInline(entry.name)}`, `- ref: ${mdInline(entry.ref)}`, `- purpose: ${mdInline(entry.purpose)}`, `- present: ${entry.present}`, `- commit: ${entry.commit ? mdInline(entry.commit) : "(none)"}`, `- dirty: ${entry.dirty}`);
+				lines.push(`### ${mdInline(entry.name)}`, `- ref: ${mdInline(entry.ref)}`, `- purpose: ${mdInline(entry.purpose)}`, `- present: ${entry.present}`, `- stagedCommit: ${entry.stagedCommit ? mdInline(entry.stagedCommit) : "(none)"}`, `- committedCommit: ${entry.committedCommit ? mdInline(entry.committedCommit) : "(none)"}`, `- checkedOutCommit: ${entry.checkedOutCommit ? mdInline(entry.checkedOutCommit) : "(none)"}`, `- dirty: ${entry.dirty}`);
 				if (entry.staleNoteIds.length > 0) lines.push(`- staleNoteIds: ${entry.staleNoteIds.map(mdInline).join(", ")}`);
 			}
 			if (r.repos.length === 0) lines.push("(none)");
@@ -66,6 +107,28 @@ const renderMarkdown = (data) => {
 			if (Object.keys(r.repos).length === 0) lines.push("(none)");
 			return lines.join("\n");
 		}
+		case "drift": {
+			const r = data.report;
+			const lines = [
+				`# repos drift`,
+				``,
+				`clean: ${r.clean}`,
+				``,
+				`| name | kind | detail |`,
+				`| --- | --- | --- |`
+			];
+			for (const d of r.drifts) lines.push(`| ${mdInline(d.name)} | ${mdInline(d.kind)} | ${mdInline(d.detail)} |`);
+			if (r.drifts.length === 0) lines.push(``, `(none)`);
+			return lines.join("\n");
+		}
+		case "gitmodules": {
+			const lines = [`# repos gitmodules`, ``];
+			if (data.parseError) lines.push(`parse error: ${mdInline(data.parseError)}`, ``);
+			lines.push(`| name | path | url | branch | shallow |`, `| --- | --- | --- | --- | --- |`);
+			for (const entry of data.entries) lines.push(`| ${mdInline(entry.name)} | ${mdInline(entry.path)} | ${mdInline(entry.url)} | ${entry.branch === void 0 ? "(none)" : mdInline(entry.branch)} | ${entry.shallow === void 0 ? "(unset)" : entry.shallow} |`);
+			if (data.entries.length === 0) lines.push(``, `(none)`);
+			return lines.join("\n");
+		}
 	}
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
@@ -88,8 +151,41 @@ const reposInspect = (args, fallbackCwd) => Effect.gen(function* () {
 			mode: "config",
 			result: yield* (yield* Repos.ReposConfigStore).read(root)
 		};
+		case "drift": return {
+			mode: "drift",
+			report: yield* (yield* Repos.ReposDrift).check(root)
+		};
+		case "gitmodules": {
+			const fs = yield* FileSystem.FileSystem;
+			const gitmodulesPath = (yield* Path.Path).join(root, ".gitmodules");
+			const text = yield* fs.readFileString(gitmodulesPath).pipe(Effect.map(Option.some), Effect.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect.succeed(Option.none()) : Effect.fail(new Repos.GitSubmoduleError({
+				command: "read .gitmodules",
+				cwd: gitmodulesPath,
+				reason: error.message
+			}))));
+			if (Option.isNone(text)) return {
+				mode: "gitmodules",
+				entries: []
+			};
+			const parsed = Gitmodules.parseResult(text.value);
+			if (Result.isFailure(parsed)) return {
+				mode: "gitmodules",
+				entries: [],
+				parseError: parsed.failure.message
+			};
+			const decoded = Schema.decodeUnknownResult(Schema.Array(GitmodulesEntrySchema))(parsed.success.entries);
+			if (Result.isFailure(decoded)) return {
+				mode: "gitmodules",
+				entries: [],
+				parseError: `unexpected .gitmodules entry shape: ${decoded.failure.message}`
+			};
+			return {
+				mode: "gitmodules",
+				entries: decoded.success
+			};
+		}
 	}
 });
 
 //#endregion
-export { ReposConfigResult, ReposInspectAsMarkdown, ReposInspectResult, ReposStatusResult, reposInspect };
+export { ReposConfigResult, ReposDriftResult, ReposGitmodulesResult, ReposInspectAsMarkdown, ReposInspectResult, ReposStatusResult, reposInspect };

package/tools/repos-manage.js

@@ -40,12 +40,24 @@ const NoteRequest = Schema.TaggedStruct("note", {
 	if (request.op === "promote" && (request.id === void 0 || request.into === void 0)) return "note op \"promote\" requires both `id` and `into`";
 	return true;
 }));
+/** `remove` requires only `name`. */
+const RemoveRequest = Schema.TaggedStruct("remove", { name: Schema.String });
+/** `rename` requires `name` (the old name) and `newName`. */
+const RenameRequest = Schema.TaggedStruct("rename", {
+	name: Schema.String,
+	newName: Schema.String
+});
+/** `restore`'s `names` is optional and repeatable, mirroring `add`'s `sparse`; omitted means "every dirty entry". */
+const RestoreRequest = Schema.TaggedStruct("restore", { names: Schema.optional(Schema.Array(Schema.String)) });
 /** Internal tagged-union request the flat wire args decode into. */
 const ReposManageRequest = Schema.Union([
 	SyncRequest,
 	PinRequest,
 	AddRequest,
-	NoteRequest
+	NoteRequest,
+	RemoveRequest,
+	RenameRequest,
+	RestoreRequest
 ]);
 /** `sync` result variant. */
 const ReposManageSyncResult = Schema.Struct({
@@ -67,16 +79,34 @@ const ReposManageNoteResult = Schema.Struct({
 	action: Schema.Literal("note"),
 	result: Repos.ReposNoteResult
 }).annotate({ identifier: "ReposManageNoteResult" });
+/** `remove` result variant. */
+const ReposManageRemoveResult = Schema.Struct({
+	action: Schema.Literal("remove"),
+	result: Repos.ReposRemoveResult
+}).annotate({ identifier: "ReposManageRemoveResult" });
+/** `rename` result variant. */
+const ReposManageRenameResult = Schema.Struct({
+	action: Schema.Literal("rename"),
+	result: Repos.ReposRenameResult
+}).annotate({ identifier: "ReposManageRenameResult" });
+/** `restore` result variant. */
+const ReposManageRestoreResult = Schema.Struct({
+	action: Schema.Literal("restore"),
+	result: Repos.ReposRestoreResult
+}).annotate({ identifier: "ReposManageRestoreResult" });
 /** The `repos_manage` tool result — a discriminated union keyed by `action`. */
 const ReposManageResult = Schema.Union([
 	ReposManageSyncResult,
 	ReposManagePinResult,
 	ReposManageAddResult,
-	ReposManageNoteResult
+	ReposManageNoteResult,
+	ReposManageRemoveResult,
+	ReposManageRenameResult,
+	ReposManageRestoreResult
 ]).annotate({
 	identifier: "ReposManageResult",
 	title: "repos_manage result",
-	description: "Result of a mutating repos action: sync, pin, add, or note."
+	description: "Result of a mutating repos action: sync, pin, add, note, remove, rename, or restore."
 });
 /** Render the structured result as a markdown transcript. */
 const renderMarkdown = (data) => {
@@ -93,7 +123,11 @@ const renderMarkdown = (data) => {
 				``,
 				...section("Up to date", r.upToDate),
 				``,
-				...section("Cleared locks", r.clearedLocks)
+				...section("Cleared locks", r.clearedLocks),
+				``,
+				...section("URL synced", r.urlSynced),
+				``,
+				...section("Registered", r.registered)
 			].join("\n");
 		}
 		case "pin": {
@@ -136,6 +170,54 @@ const renderMarkdown = (data) => {
 				`noteCount: ${r.noteCount}`
 			].join("\n");
 		}
+		case "remove": {
+			const r = data.result;
+			const lines = [
+				`# repos remove — ${mdInline(r.name)}`,
+				``,
+				`path: ${mdInline(r.path)}`,
+				``,
+				`## Commit message`,
+				``,
+				mdInline(r.commitMessage),
+				``,
+				`## Removed notes`,
+				``
+			];
+			if (r.removedNotes.length > 0) lines.push(`Promote any durable ones elsewhere before committing:`, ...r.removedNotes.map((note) => `- ${mdInline(note.id)} (${mdInline(note.ref)}): ${mdInline(note.note)}`));
+			else lines.push("(none)");
+			lines.push(``, `REVIEW AND COMMIT: the manifest, .gitmodules, and gitlink removal are already staged — review and commit using the message above.`);
+			return lines.join("\n");
+		}
+		case "rename": {
+			const r = data.result;
+			return [
+				`# repos rename — ${mdInline(r.oldName)} → ${mdInline(r.newName)}`,
+				``,
+				`path: ${mdInline(r.path)}`,
+				``,
+				`## Commit message`,
+				``,
+				mdInline(r.commitMessage),
+				``,
+				`REVIEW AND COMMIT: the moved worktree, .gitmodules section, and manifest key are already staged — review and commit using the message above.`
+			].join("\n");
+		}
+		case "restore": {
+			const r = data.result;
+			const lines = [
+				`# repos restore`,
+				``,
+				`## Restored`,
+				``
+			];
+			if (r.restored.length > 0) lines.push(`DESTRUCTIVE: any uncommitted worktree edits and untracked files in these repos were discarded — the working tree was hard-reset to the commit below and sparse paths re-applied.`, ``, ...r.restored.map((entry) => `- ${mdInline(entry.name)} → ${mdInline(entry.commit)}`));
+			else lines.push("(none)");
+			lines.push(``, `## Skipped (clean)`, ``);
+			if (r.skippedClean.length > 0) lines.push(...r.skippedClean.map((name) => `- ${mdInline(name)}`));
+			else lines.push("(none)");
+			return lines.join("\n");
+		}
 	}
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
@@ -192,8 +274,20 @@ const reposManage = (args, fallbackCwd) => Effect.gen(function* () {
 				result: yield* manager.note(root, request.name, noteOp)
 			};
 		}
+		case "remove": return {
+			action: "remove",
+			result: yield* manager.remove(root, request.name)
+		};
+		case "rename": return {
+			action: "rename",
+			result: yield* manager.rename(root, request.name, request.newName)
+		};
+		case "restore": return {
+			action: "restore",
+			result: yield* manager.restore(root, request.names)
+		};
 	}
 });
 
 //#endregion
-export { ReposManageAddResult, ReposManageAsMarkdown, ReposManageNoteResult, ReposManagePinResult, ReposManageResult, ReposManageSyncResult, reposManage };
+export { ReposManageAddResult, ReposManageAsMarkdown, ReposManageNoteResult, ReposManagePinResult, ReposManageRemoveResult, ReposManageRenameResult, ReposManageRestoreResult, ReposManageResult, ReposManageSyncResult, reposManage };