@savvy-web/cli 2.3.0 → 2.4.0

package/README.md

@@ -55,11 +55,11 @@ npx savvy clean --globs dist,.turbo,coverage
 - `savvy commit` — the husky/Claude hook handlers (session-start, pre-commit-message, post-commit-verify).
 - `savvy changeset` — changeset lint, check, transform, version, config validation, and dependency changesets.
 - `savvy lint` — formatters for package.json, the pnpm workspace file and YAML.
-- `savvy repos` — the vendored reference repos declared in `.repos/config.json`: `status`, `sync`, `pin`, `add` and `note`.
+- `savvy repos` — the vendored reference repos declared in `.repos/config.json`: `status` (with `--drift`), `sync`, `pin`, `add`, `note`, `remove`, `rename` and `restore`.
 
 ## Vendored repos are read-only
 
-`savvy repos sync`, `add` and `pin` leave every vendored tree under `.repos/` read-only at the OS level — files `0444`, directories `0555`. Reading a vendored source needs no extra step; writing to one fails with `EACCES` by design, because those trees mirror an upstream repo at a pinned ref and any local edit is lost on the next sync.
+`savvy repos sync`, `add`, `pin`, `remove`, `rename` and `restore` leave every vendored tree under `.repos/` read-only at the OS level — files `0444`, directories `0555` (an executable file locks at `0555` instead, and unlocks back to `0755` rather than losing its executable bit). Reading a vendored source needs no extra step; writing to one fails with `EACCES` by design, because those trees mirror an upstream repo at a pinned ref and any local edit is lost on the next sync. A dirty tree from a hand bypass recovers with `savvy repos restore <name...>` (or with no names, every dirty tree) rather than a manual `git reset`. Restore is destructive by design: it hard-resets each tree it touches to the pinned commit, so uncommitted edits and untracked files in that tree are gone.
 
 ```bash
 npx savvy repos sync
@@ -67,9 +67,15 @@ npx savvy repos sync
 
 npx savvy repos pin effect v4.0.0
 # fetches, checks out the new ref, re-locks, and stages the gitlink and manifest
+
+npx savvy repos restore
+# hard-resets every dirty tree to its pinned commit and reports the clean ones as skipped
+
+npx savvy repos status --drift
+# reports where the manifest, .gitmodules, the worktree and git submodule status disagree
 ```
 
-A manual `chmod` only holds until the next `sync` or `pin`. Route changes through `savvy repos` instead.
+A manual `chmod` only holds until the next mutation. Route changes through `savvy repos` instead.
 
 Run any command with `--help` to see its full surface:
 

package/cli/index.js

@@ -76,7 +76,7 @@ const rootCommand = Command.make("savvy").pipe(Command.withSubcommands([
 * CLI application: reads argv from the Stdio service provided by NodeServices.
 * (v4's `Command.run` takes only `version` — the name comes from the root command.)
 */
-const cli = Command.run(rootCommand, { version: "2.3.0" });
+const cli = Command.run(rootCommand, { version: "2.4.0" });
 /**
 * Shared workspace services from `@effected/workspaces`, wired as a
 * self-contained unit and built ONCE (layers memoize by reference).
@@ -115,7 +115,7 @@ const InspectorAndAnalyzerLive = Changesets.BranchAnalyzer.layer.pipe(Layer.prov
 * `Repos.ReposLockdown.layer` dependencies plus the shared `Git` service.
 * Platform requirements (`FileSystem`, `Path`) flow up to `NodeServices.layer`.
 */
-const ReposGroupLive = Repos.ReposManager.layer.pipe(Layer.provide(Repos.ReposConfigStore.layer), Layer.provide(Repos.ReposLockdown.layer), Layer.provide(GitLive));
+const ReposGroupLive = Layer.mergeAll(Repos.ReposManager.layer, Repos.ReposDrift.layer).pipe(Layer.provide(Repos.ReposConfigStore.layer), Layer.provide(Repos.ReposLockdown.layer), Layer.provide(GitLive));
 /**
 * `ToolDiscovery` from `@effected/commands`, wired to this workspace. Its
 * `LocalExec` contract — the argv prefix that runs a project-local binary — is

package/commands/repos/commands/remove.js

@@ -0,0 +1,72 @@
+import { Repos } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+//#region src/commands/repos/commands/remove.ts
+/**
+* `repos remove` command -- unvendor a `.repos/` submodule.
+*
+* @remarks
+* A thin adapter over {@link Repos.ReposManager.remove}: deinitializes and
+* removes the submodule's gitlink, worktree, and module gitdir, drops its
+* `.gitmodules` section, and removes the manifest entry -- it does not
+* commit, so the caller reviews and commits the staged removal with the
+* ready-made message the result carries. Any notes the entry carried are
+* surfaced in the result so a durable one can be promoted elsewhere first.
+*
+* A `ReposConfigError` with kind `"missing"` -- nothing vendored yet -- is
+* the common, friendly case and always exits 0. A `ReposConfigError` with
+* kind `"invalid"` means the manifest exists but is corrupt or unreadable.
+* `RepoNotFoundError` means the named repo isn't in the manifest -- this is
+* a REAL failure (unlike the "missing manifest" case above), since removing
+* a name that was never vendored is almost always a typo the caller should
+* see. `GitSubmoduleError` means the underlying git command failed, and
+* `ReposLockdownError` means the OS-permission lockdown pass on a vendored
+* tree failed -- all four (invalid config, not-found, git failure, lockdown
+* failure) are real failures, logged and reported via a non-zero exit code.
+*
+* @example
+* ```bash
+* savvy repos remove my-repo
+* ```
+*
+* @internal
+*/
+/* v8 ignore start -- CLI option/arg definitions */
+const nameArg = Argument.string("name");
+const cwdOption = Flag.directory("cwd").pipe(Flag.withDescription("Repo root to remove within"), Flag.withDefault("."));
+/* v8 ignore stop */
+/**
+* Remove handler; exported for tests.
+*
+* @internal
+*/
+const runReposRemove = (cwd, name) => Effect.gen(function* () {
+	const result = yield* (yield* Repos.ReposManager).remove(cwd, name);
+	yield* Effect.log(`${result.name}: removed (${result.path})`);
+	yield* Effect.log(result.commitMessage);
+	yield* Effect.log("staged — review and commit");
+	for (const note of result.removedNotes) yield* Effect.log(`warning: note ${note.id} (${note.ref}) was removed with the entry — promote first if durable`);
+}).pipe(Effect.catchTag("ReposConfigError", (error) => {
+	if (error.kind === "missing") return Effect.log("no .repos/config.json — nothing vendored");
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("RepoNotFoundError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("GitSubmoduleError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("ReposLockdownError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}));
+/* v8 ignore start -- CLI registration; handler tested via runReposRemove */
+const removeCommand = Command.make("remove", {
+	name: nameArg,
+	cwd: cwdOption
+}, ({ name, cwd }) => runReposRemove(cwd, name)).pipe(Command.withDescription("Unvendor a repo under .repos/; stages the removal without committing"));
+/* v8 ignore stop */
+
+//#endregion
+export { removeCommand, runReposRemove };

package/commands/repos/commands/rename.js

@@ -0,0 +1,74 @@
+import { Repos } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+//#region src/commands/repos/commands/rename.ts
+/**
+* `repos rename` command -- rename a vendored `.repos/` submodule's manifest
+* key and worktree.
+*
+* @remarks
+* A thin adapter over {@link Repos.ReposManager.rename}: moves the worktree
+* (`git mv`), re-points the module gitdir's `core.worktree` values,
+* canonicalizes the `.gitmodules` section name, and renames the manifest
+* key -- it does not commit, so the caller reviews and commits the staged
+* rename with the ready-made message the result carries.
+*
+* A `ReposConfigError` with kind `"missing"` -- nothing vendored yet -- is
+* the common, friendly case and always exits 0. A `ReposConfigError` with
+* kind `"invalid"` means either the manifest exists but is corrupt/unreadable
+* OR the requested new name is invalid/already vendored. `RepoNotFoundError`
+* means the old name isn't in the manifest -- this is a REAL failure, since
+* renaming a name that was never vendored is almost always a typo the caller
+* should see. `GitSubmoduleError` means the underlying git command failed,
+* and `ReposLockdownError` means the OS-permission lockdown pass on a
+* vendored tree failed -- all four (invalid config, not-found, git failure,
+* lockdown failure) are real failures, logged and reported via a non-zero
+* exit code.
+*
+* @example
+* ```bash
+* savvy repos rename old-name new-name
+* ```
+*
+* @internal
+*/
+/* v8 ignore start -- CLI option/arg definitions */
+const oldNameArg = Argument.string("old-name");
+const newNameArg = Argument.string("new-name");
+const cwdOption = Flag.directory("cwd").pipe(Flag.withDescription("Repo root to rename within"), Flag.withDefault("."));
+/* v8 ignore stop */
+/**
+* Rename handler; exported for tests.
+*
+* @internal
+*/
+const runReposRename = (cwd, oldName, newName) => Effect.gen(function* () {
+	const result = yield* (yield* Repos.ReposManager).rename(cwd, oldName, newName);
+	yield* Effect.log(`${result.oldName}: renamed to ${result.newName} (${result.path})`);
+	yield* Effect.log(result.commitMessage);
+	yield* Effect.log("staged — review and commit");
+}).pipe(Effect.catchTag("ReposConfigError", (error) => {
+	if (error.kind === "missing") return Effect.log("no .repos/config.json — nothing vendored");
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("RepoNotFoundError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("GitSubmoduleError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("ReposLockdownError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}));
+/* v8 ignore start -- CLI registration; handler tested via runReposRename */
+const renameCommand = Command.make("rename", {
+	oldName: oldNameArg,
+	newName: newNameArg,
+	cwd: cwdOption
+}, ({ oldName, newName, cwd }) => runReposRename(cwd, oldName, newName)).pipe(Command.withDescription("Rename a vendored repo's manifest key and worktree; stages the change without committing"));
+/* v8 ignore stop */
+
+//#endregion
+export { renameCommand, runReposRename };

package/commands/repos/commands/restore.js

@@ -0,0 +1,78 @@
+import { Repos } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+//#region src/commands/repos/commands/restore.ts
+/**
+* `repos restore` command -- hard-reset one or more vendored `.repos/`
+* submodules back to their pinned gitlink commit.
+*
+* @remarks
+* A thin adapter over {@link Repos.ReposManager.restore}: explicit only --
+* never invoked by `sync` or any other implicit path. DESTRUCTIVE to
+* uncommitted worktree edits and untracked files in the repos it touches:
+* each targeted repo is hard-reset to its staged gitlink commit (falling
+* back to the committed one) and its sparse-checkout paths re-applied.
+* With one or more `name` arguments, exactly those repos are restored, even
+* if already clean -- an explicit ask is always honored. With no names, every
+* DIRTY repo (per `status`) is restored and the clean ones are reported as
+* skipped.
+*
+* A `ReposConfigError` with kind `"missing"` -- nothing vendored yet -- is
+* the common, friendly case and always exits 0. A `ReposConfigError` with
+* kind `"invalid"` means the manifest exists but is corrupt or unreadable.
+* `RepoNotFoundError` means an explicitly named repo isn't in the manifest --
+* a real failure, since restoring a name that was never vendored is almost
+* always a typo the caller should see. `GitSubmoduleError` means the
+* underlying git command failed (including the case where a repo has
+* neither a staged nor a committed gitlink commit to restore to), and
+* `ReposLockdownError` means the OS-permission lockdown pass on a vendored
+* tree failed -- all four are real failures, logged and reported via a
+* non-zero exit code.
+*
+* @example
+* ```bash
+* savvy repos restore my-repo
+* savvy repos restore my-repo other-repo
+* savvy repos restore
+* ```
+*
+* @internal
+*/
+/* v8 ignore start -- CLI option/arg definitions */
+const namesArg = Argument.string("name").pipe(Argument.variadic());
+const cwdOption = Flag.directory("cwd").pipe(Flag.withDescription("Repo root to restore within"), Flag.withDefault("."));
+/* v8 ignore stop */
+/**
+* Restore handler; exported for tests.
+*
+* @internal
+*/
+const runReposRestore = (cwd, names) => Effect.gen(function* () {
+	const result = yield* (yield* Repos.ReposManager).restore(cwd, names.length > 0 ? names : void 0);
+	for (const entry of result.restored) yield* Effect.log(`${entry.name}: restored to ${entry.commit}`);
+	for (const name of result.skippedClean) yield* Effect.log(`${name}: clean — skipped`);
+	if (result.restored.length === 0 && result.skippedClean.length === 0) yield* Effect.log("nothing to restore");
+}).pipe(Effect.catchTag("ReposConfigError", (error) => {
+	if (error.kind === "missing") return Effect.log("no .repos/config.json — nothing vendored");
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("RepoNotFoundError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("GitSubmoduleError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}), Effect.catchTag("ReposLockdownError", (error) => {
+	process.exitCode = 1;
+	return Effect.log(error.message);
+}));
+/* v8 ignore start -- CLI registration; handler tested via runReposRestore */
+const restoreCommand = Command.make("restore", {
+	names: namesArg,
+	cwd: cwdOption
+}, ({ names, cwd }) => runReposRestore(cwd, names)).pipe(Command.withDescription("Hard-reset vendored repos to their pinned commit; DESTRUCTIVE to uncommitted worktree edits. Given no names, restores every dirty repo"));
+/* v8 ignore stop */
+
+//#endregion
+export { restoreCommand, runReposRestore };

package/commands/repos/commands/status.js

@@ -16,16 +16,27 @@ import { Command, Flag } from "effect/unstable/cli";
 * `"invalid"` means the manifest exists but is corrupt or unreadable -- that
 * is a real failure, logged and reported via a non-zero exit code.
 *
+* With `--drift`, {@link Repos.ReposDrift.check} also runs (after the status
+* check), reconciling the manifest, `.gitmodules`, the worktree, and `git
+* submodule status`. Each detected drift prints as one line
+* (`<name>: <kind> — <detail>`), and any drift flips the exit code to 1,
+* mirroring the existing `!clean` rule for the status report itself. Because
+* both calls read the same manifest, a missing manifest fails at the status
+* call before the drift check ever runs, so the friendly exit-0 case is
+* unaffected by `--drift`.
+*
 * @example
 * ```bash
 * savvy repos status
 * savvy repos status --json
+* savvy repos status --drift
 * ```
 *
 * @internal
 */
 /* v8 ignore start -- CLI option definitions */
 const jsonOption = Flag.boolean("json").pipe(Flag.withDescription("Emit the structured drift report as JSON"), Flag.withDefault(false));
+const driftOption = Flag.boolean("drift").pipe(Flag.withDescription("Also reconcile the manifest, .gitmodules, worktree, and git submodule status"), Flag.withDefault(false));
 const cwdOption = Flag.directory("cwd").pipe(Flag.withDescription("Repo root to inspect"), Flag.withDefault("."));
 /* v8 ignore stop */
 /**
@@ -33,11 +44,20 @@ const cwdOption = Flag.directory("cwd").pipe(Flag.withDescription("Repo root to
 *
 * @internal
 */
-const runReposStatus = (cwd, json) => Effect.gen(function* () {
+const runReposStatus = (cwd, json, drift = false) => Effect.gen(function* () {
 	const report = yield* (yield* Repos.ReposManager).status(cwd);
 	if (!report.clean) process.exitCode = 1;
+	let driftReport;
+	if (drift) {
+		driftReport = yield* (yield* Repos.ReposDrift).check(cwd);
+		if (!driftReport.clean) process.exitCode = 1;
+	}
 	if (json) {
-		yield* Console.log(JSON.stringify(report, null, 2));
+		const payload = driftReport === void 0 ? report : {
+			...report,
+			drift: driftReport
+		};
+		yield* Console.log(JSON.stringify(payload, null, 2));
 		return;
 	}
 	for (const repo of report.repos) {
@@ -48,6 +68,7 @@ const runReposStatus = (cwd, json) => Effect.gen(function* () {
 		].filter((f) => f !== void 0);
 		yield* Effect.log(`${repo.name} @ ${repo.ref}${flags.length > 0 ? ` [${flags.join(", ")}]` : " [ok]"}`);
 	}
+	if (driftReport !== void 0) for (const item of driftReport.drifts) yield* Effect.log(`${item.name}: ${item.kind} — ${item.detail}`);
 }).pipe(Effect.catchTag("ReposConfigError", (error) => {
 	if (error.kind === "missing") {
 		if (json) return Console.log(JSON.stringify({
@@ -62,8 +83,9 @@ const runReposStatus = (cwd, json) => Effect.gen(function* () {
 /* v8 ignore start -- CLI registration; handler tested via runReposStatus */
 const statusCommand = Command.make("status", {
 	json: jsonOption,
+	drift: driftOption,
 	cwd: cwdOption
-}, ({ json, cwd }) => runReposStatus(cwd, json)).pipe(Command.withDescription("Drift report: gitlink vs manifest ref, dirty and unsynced submodules"));
+}, ({ json, drift, cwd }) => runReposStatus(cwd, json, drift)).pipe(Command.withDescription("Drift report: gitlink vs manifest ref, dirty and unsynced submodules"));
 /* v8 ignore stop */
 
 //#endregion

package/commands/repos/commands/sync.js

@@ -8,8 +8,10 @@ import { Command, Flag } from "effect/unstable/cli";
 *
 * @remarks
 * A thin adapter over {@link Repos.ReposManager.sync}: initializes missing
-* submodules, re-applies sparse-checkout patterns, and clears stale git
-* locks left behind by an interrupted fetch. Sync is idempotent repair, so
+* submodules, re-applies sparse-checkout patterns, clears stale git locks
+* left behind by an interrupted fetch, reconciles a submodule's URL when it
+* drifts from the manifest, and registers an orphan manifest entry (no
+* gitlink at all) from scratch. Sync is idempotent repair, so
 * a `ReposConfigError` with kind `"missing"` -- the common, friendly case
 * (nothing to sync yet) -- always exits 0. A `ReposConfigError` with kind
 * `"invalid"` means the manifest exists but is corrupt or unreadable,
@@ -38,7 +40,9 @@ const runReposSync = (cwd) => Effect.gen(function* () {
 	for (const name of report.clearedLocks) yield* Effect.log(`${name}: cleared stale lock`);
 	for (const name of report.initialized) yield* Effect.log(`${name}: initialized`);
 	for (const name of report.sparseApplied) yield* Effect.log(`${name}: sparse-checkout applied`);
-	if (report.initialized.length === 0 && report.sparseApplied.length === 0 && report.clearedLocks.length === 0) yield* Effect.log("all vendored repos up to date");
+	for (const name of report.urlSynced) yield* Effect.log(`${name}: url reconciled`);
+	for (const name of report.registered) yield* Effect.log(`${name}: registered`);
+	if (report.initialized.length === 0 && report.sparseApplied.length === 0 && report.clearedLocks.length === 0 && report.urlSynced.length === 0 && report.registered.length === 0) yield* Effect.log("all vendored repos up to date");
 }).pipe(Effect.catchTag("ReposConfigError", (error) => {
 	if (error.kind === "missing") return Effect.log("no .repos/config.json — nothing vendored");
 	process.exitCode = 1;

package/commands/repos/index.js

@@ -1,6 +1,9 @@
 import { addCommand, runReposAdd } from "./commands/add.js";
 import { noteCommand, runReposNote } from "./commands/note.js";
 import { pinCommand, runReposPin } from "./commands/pin.js";
+import { removeCommand, runReposRemove } from "./commands/remove.js";
+import { renameCommand, runReposRename } from "./commands/rename.js";
+import { restoreCommand, runReposRestore } from "./commands/restore.js";
 import { runReposStatus, statusCommand } from "./commands/status.js";
 import { runReposSync, syncCommand } from "./commands/sync.js";
 import { Command } from "effect/unstable/cli";
@@ -12,7 +15,10 @@ const _reposCommand = Command.make("repos").pipe(Command.withSubcommands([
 	syncCommand,
 	pinCommand,
 	addCommand,
-	noteCommand
+	noteCommand,
+	removeCommand,
+	renameCommand,
+	restoreCommand
 ]), Command.withDescription("Vendored reference repos under .repos/"));
 /**
 * The `savvy repos` command group.
@@ -25,13 +31,22 @@ const _reposCommand = Command.make("repos").pipe(Command.withSubcommands([
 * annotation preserves the exact Error/Requirements channels, so the root
 * layer graph stays compiler-validated.
 *
-* The requirements channel names `Repos.ReposManager` rather than `never`:
-* `Command.withSubcommands` propagates each subcommand's requirements up into
-* the group's `R`, which the root assembly discharges via `AppLive`.
+* The requirements channel names `Repos.ReposManager | Repos.ReposDrift`
+* rather than `never`: `Command.withSubcommands` propagates each
+* subcommand's requirements up into the group's `R`, which the root assembly
+* discharges via `AppLive`. `Repos.ReposDrift` joins the union because
+* `status --drift` runs `Repos.ReposDrift.check` after the status check.
 *
-* The error channel now also names `Repos.ReposLockdownError`: `sync`/`add`/
-* `pin` unlock and re-lock the vendored tree around their git mutations
-* (Task 2), so a lockdown chmod failure can surface from any of the three.
+* The error channel is `Repos.GitSubmoduleError` alone: `add`/`pin`/`note`/
+* `remove`/`rename`/`restore`/`sync` each `catchTag` every error their
+* underlying `ReposManager` method can produce — `ReposConfigError`,
+* `GitSubmoduleError`, `RepoNotFoundError`, `NoteNotFoundError`, and (for the
+* six ops that unlock/re-lock the vendored tree around a git mutation)
+* `ReposLockdownError` — down to a logged message and a non-zero exit code,
+* so none of those propagate past the handler. `status` only `catchTag`s
+* `ReposConfigError`; `GitSubmoduleError` from either `ReposManager.status`
+* or (under `--drift`) `Repos.ReposDrift.check` is the sole channel that
+* escapes uncaught, so it is the only member left in this union.
 */
 const reposCommand = _reposCommand;
 

package/index.d.ts

@@ -272,7 +272,7 @@ declare const lintCommand: Command.Command<"lint", {}, {}, import("@effected/yam
  *
  * @internal
  */
-declare const runReposStatus: (cwd: string, json: boolean) => Effect.Effect<void, Repos.GitSubmoduleError, Repos.ReposManager>;
+declare const runReposStatus: (cwd: string, json: boolean, drift?: boolean) => Effect.Effect<void, Repos.GitSubmoduleError, Repos.ReposDrift | Repos.ReposManager>;
 //#endregion
 //#region src/commands/repos/commands/sync.d.ts
 /**
@@ -294,15 +294,24 @@ declare const runReposSync: (cwd: string) => Effect.Effect<void, never, Repos.Re
  * annotation preserves the exact Error/Requirements channels, so the root
  * layer graph stays compiler-validated.
  *
- * The requirements channel names `Repos.ReposManager` rather than `never`:
- * `Command.withSubcommands` propagates each subcommand's requirements up into
- * the group's `R`, which the root assembly discharges via `AppLive`.
- *
- * The error channel now also names `Repos.ReposLockdownError`: `sync`/`add`/
- * `pin` unlock and re-lock the vendored tree around their git mutations
- * (Task 2), so a lockdown chmod failure can surface from any of the three.
+ * The requirements channel names `Repos.ReposManager | Repos.ReposDrift`
+ * rather than `never`: `Command.withSubcommands` propagates each
+ * subcommand's requirements up into the group's `R`, which the root assembly
+ * discharges via `AppLive`. `Repos.ReposDrift` joins the union because
+ * `status --drift` runs `Repos.ReposDrift.check` after the status check.
+ *
+ * The error channel is `Repos.GitSubmoduleError` alone: `add`/`pin`/`note`/
+ * `remove`/`rename`/`restore`/`sync` each `catchTag` every error their
+ * underlying `ReposManager` method can produce — `ReposConfigError`,
+ * `GitSubmoduleError`, `RepoNotFoundError`, `NoteNotFoundError`, and (for the
+ * six ops that unlock/re-lock the vendored tree around a git mutation)
+ * `ReposLockdownError` — down to a logged message and a non-zero exit code,
+ * so none of those propagate past the handler. `status` only `catchTag`s
+ * `ReposConfigError`; `GitSubmoduleError` from either `ReposManager.status`
+ * or (under `--drift`) `Repos.ReposDrift.check` is the sole channel that
+ * escapes uncaught, so it is the only member left in this union.
  */
-declare const reposCommand: Command.Command<"repos", Record<string, never>, Record<string, never>, Repos.GitSubmoduleError | Repos.ReposLockdownError, Repos.ReposManager>;
+declare const reposCommand: Command.Command<"repos", Record<string, never>, Record<string, never>, Repos.GitSubmoduleError, Repos.ReposManager | Repos.ReposDrift>;
 //#endregion
 export { changesetCommand, checkCommand, commitCommand, initCommand, lintCommand, reposCommand, runChangesetCheck, runChangesetInit, runCheck, runCli, runCommitCheck, runCommitInit, runInit, runLintCheck, runLintInit, runReposStatus, runReposSync };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/cli",
-	"version": "2.3.0",
+	"version": "2.4.0",
 	"private": false,
 	"description": "The savvy CLI — unified commit, changeset, and lint commands for the Silk Suite",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/cli",
@@ -33,12 +33,12 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-beta.101",
 		"@effected/commands": "^0.3.1",
-		"@effected/git": "^0.5.2",
+		"@effected/git": "^0.6.0",
 		"@effected/jsonc": "^0.5.2",
 		"@effected/templates": "^0.1.1",
-		"@effected/workspaces": "^0.10.0",
+		"@effected/workspaces": "^0.10.2",
 		"@effected/yaml": "^0.6.1",
-		"@savvy-web/silk-effects": "5.4.0",
+		"@savvy-web/silk-effects": "5.5.0",
 		"effect": "4.0.0-beta.101"
 	}
 }