magus-cli 7.5.2 → 7.5.3

package/src/__tests__/profile-state.test.ts

@@ -13,7 +13,7 @@ import { ensureManifest, profileGate } from "../cli/bootstrap.js";
 import { reportProfileState, runDoctorCommand } from "../cli/doctor.js";
 import { runModelsCommand } from "../cli/models.js";
 import { route } from "../cli/router.js";
-import { installPlugin, uninstallPlugin } from "../services/claude-cli.js";
+import { runUpdateCommand } from "../cli/update.js";
 import {
 	readSettings,
 	writeMcpConfig,
@@ -25,6 +25,7 @@ import type { ModelsConfig } from "../services/models-core.js";
 import { reconcileActiveProfile } from "../services/profile-absorb.js";
 import {
 	activateProfile,
+	activationNotes,
 	regenerateLiveFiles,
 	trackedGeneratedFiles,
 } from "../services/profile-activate.js";
@@ -44,10 +45,6 @@ import {
 	switchToProfile,
 } from "../services/profile-state.js";
 import { applyUserProfile } from "../services/profiles.js";
-import {
-	GitCheckError,
-	TrackedLiveFileError,
-} from "../services/tracked-live-files.js";
 import type { ProfileManifest } from "../types/index.js";
 
 const MANIFEST: ProfileManifest = {
@@ -686,7 +683,7 @@ function git(cwd: string, ...args: string[]) {
 	);
 }
 
-describe("generated files git still tracks", () => {
+describe("generated files git still tracks: written, and warned about", () => {
 	/** A repo that committed profiles.json AND settings.json, like magus-src. */
 	async function commitTrackedSettings(): Promise<void> {
 		expect(git(project, "init", "-q").status).toBe(0);
@@ -698,61 +695,63 @@ describe("generated files git still tracks", () => {
 		expect(git(project, "commit", "-q", "-m", "init").status).toBe(0);
 	}
 
-	/** Everything B1 says must not change when magus refuses. */
-	async function untouched(): Promise<void> {
-		expect(git(project, "status", "--porcelain").stdout).toBe("");
-		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
-			false,
-		);
-		expect(await fs.pathExists(backupRoot(project))).toBe(false);
-		expect(await fs.pathExists(join(project, ".gitignore"))).toBe(false);
-	}
+	/** magus never runs git: nothing is staged, whatever it wrote. */
+	const nothingStaged = () =>
+		expect(git(project, "diff", "--cached", "--name-only").stdout).toBe("");
+
+	const WARNING =
+		".claude/settings.json is generated from .claude/profiles.json but tracked by git — run `git rm --cached .claude/settings.json`, then commit";
 
-	test("B1: activating over a tracked settings.json writes nothing and names the fix", async () => {
+	test("B7: activating over a tracked settings.json writes it and names the fix", async () => {
 		await commitTrackedSettings();
 
-		const error = await activateProfile(MANIFEST, "team", project, {
+		const result = await activateProfile(MANIFEST, "team", project, {
 			onDisplace: () => {},
-		}).then(
-			() => null,
-			(e: unknown) => e,
-		);
+		});
 
-		expect(error).toBeInstanceOf(TrackedLiveFileError);
-		const message = (error as Error).message;
-		expect(message).toContain(".claude/settings.json");
-		expect(message).toContain("git rm --cached .claude/settings.json");
-		expect(message).toContain("Nothing was changed.");
-		await untouched();
+		expect(result.tracked).toEqual([".claude/settings.json"]);
+		expect(activationNotes(result)).toContain(WARNING);
+		expect((await fs.readJson(settingsPath())).enabledPlugins).toEqual({
+			"dev@magus": true,
+			"terminal@magus": false,
+		});
+		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(git(project, "status", "--porcelain").stdout).toContain(
+			" M .claude/settings.json",
+		);
+		nothingStaged();
 	});
 
-	test("B1: the gate, the switch path and a startup choice all refuse, writing nothing", async () => {
+	test("B7: the gate, the switch path and a startup choice all write", async () => {
 		await commitTrackedSettings();
 
-		const prep = await prepareProfileState(project);
-		expect(prep.refusal).toBeInstanceOf(TrackedLiveFileError);
-		expect(prep.problems[0]).toContain("git rm --cached .claude/settings.json");
-		expect(await profileGate(project)).toBe(false);
-
-		const switched = await switchToProfile(project, "other", {
-			onDisplace: () => {},
-		});
-		expect(switched.activation).toBeNull();
-		expect(switched.problems[0]).toContain(".claude/settings.json");
-
 		for (const choice of [
 			{ kind: "activate", id: "team" },
 			{ kind: "adopt", id: "default-2" },
 		] as const) {
-			await expect(
-				applyProfileChoice(choice, MANIFEST, project, { onDisplace: () => {} }),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
+			const result = await applyProfileChoice(choice, MANIFEST, project, {
+				onDisplace: () => {},
+			});
+			expect(result.profileId).toBe(choice.id);
 		}
-		await untouched();
+		const prep = await prepareProfileState(project);
+		expect(prep.problems).toEqual([]);
+		expect(await profileGate(project)).toBe(true);
+
+		const switched = await switchToProfile(project, "other", {
+			onDisplace: () => {},
+		});
+		expect(switched.problems).toEqual([]);
+		expect(switched.activation?.profileId).toBe("other");
+		expect(
+			(await fs.readJson(settingsPath())).enabledPlugins["terminal@magus"],
+		).toBe(true);
+		nothingStaged();
 	});
 
-	test("B1: the CLI router exits 1 for `magus profile switch`, and writes nothing", async () => {
+	test("B7: `magus profile switch` exits 0 and warns once, running no git", async () => {
 		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const cwd = process.cwd();
 		process.chdir(project);
 		let outcome: Awaited<ReturnType<typeof route>>;
@@ -761,63 +760,47 @@ describe("generated files git still tracks", () => {
 		} finally {
 			process.chdir(cwd);
 		}
-		expect(outcome.exitCode).toBe(1);
-		expect(printed()).toContain("git rm --cached .claude/settings.json");
-		await untouched();
+		expect(outcome.exitCode).toBe(0);
+		expect(printed().split(WARNING).length - 1).toBe(1);
+		expect((await readActiveMarker(project))?.profile).toBe("other");
+		nothingStaged();
+	});
+
+	test("B7: `magus update` warns once about a tracked generated file, running no git", async () => {
+		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		// A named profile that does not exist: the command stops right after the
+		// warning, before anything reaches the network.
+		expect(await runUpdateCommand(["no-such-profile"], project)).toBe(1);
+		expect(printed().split(WARNING).length - 1).toBe(1);
+		nothingStaged();
 	});
 
-	test("B1: once settings.json is tracked, a pulled change regenerates nothing", async () => {
+	test("B7: once settings.json is tracked, a pulled change is still regenerated", async () => {
 		expect(git(project, "init", "-q").status).toBe(0);
 		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		// Somebody commits the generated file after all.
 		git(project, "add", "-f", ".claude/settings.json");
 		git(project, "add", ".claude/profiles.json");
 		expect(git(project, "commit", "-q", "-m", "oops").status).toBe(0);
-		const before = await fs.readFile(settingsPath(), "utf8");
 		// A teammate's pull changes the profile.
 		const pulled = structuredClone(MANIFEST);
 		(pulled.profiles.team as { plugins: Record<string, string> }).plugins[
 			"mnemex@magus"
 		] = "latest";
 		await writeManifest(pulled, project);
-		const manifestBefore = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
 
 		const prep = await prepareProfileState(project);
-		expect(prep.problems[0]).toContain("git rm --cached .claude/settings.json");
-		expect((await reconcileActiveProfile(project)).problems[0]).toContain(
-			".claude/settings.json",
-		);
-		await expect(regenerateLiveFiles(project)).rejects.toBeInstanceOf(
-			TrackedLiveFileError,
-		);
-		expect(await fs.readFile(settingsPath(), "utf8")).toBe(before);
-		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBefore);
-	});
 
-	test("B1: after `git rm --cached` and a commit, activation proceeds and keeps the committed profiles.json", async () => {
-		await commitTrackedSettings();
-		git(project, "rm", "-q", "--cached", ".claude/settings.json");
-		expect(git(project, "commit", "-q", "-m", "untrack").status).toBe(0);
-		const manifestBytes = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
-
-		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
-
-		expect((await lstat(settingsPath())).isFile()).toBe(true);
-		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(prep.problems).toEqual([]);
+		expect(prep.lines.join("\n")).toContain("regenerated");
 		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBytes);
+			(await fs.readJson(settingsPath())).enabledPlugins["mnemex@magus"],
+		).toBe(true);
+		nothingStaged();
 	});
 
-	test("B1: adopting a repo with no profiles.json and a tracked settings.json writes nothing", async () => {
+	test("B7: adopting a repo with no profiles.json and a tracked settings.json writes and warns", async () => {
 		await fs.remove(join(project, ".claude", "profiles.json"));
 		expect(git(project, "init", "-q").status).toBe(0);
 		await fs.outputJson(settingsPath(), {
@@ -829,112 +812,112 @@ describe("generated files git still tracks", () => {
 		const savedHome = process.env.HOME;
 		process.env.HOME = home;
 		try {
-			await expect(
-				ensureManifest(project, { allowAdopt: true }),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
+			expect(
+				await ensureManifest(project, { allowAdopt: true }),
+			).not.toBeNull();
 		} finally {
 			process.env.HOME = savedHome;
 			await rm(home, { recursive: true, force: true });
 		}
-		expect(await fs.pathExists(join(project, ".claude", "profiles.json"))).toBe(
-			false,
+		const manifest = await readManifest(project);
+		expect(Object.keys(manifest.profiles)).toHaveLength(1);
+		expect(await activeProfile(project)).toBe(
+			Object.keys(manifest.profiles)[0],
 		);
-		await untouched();
+		expect(printed()).toContain(WARNING);
+		nothingStaged();
 	});
 
-	test("B1: doctor counts a tracked live file as a problem", async () => {
+	test("B7: doctor notes a tracked live file with the fix, and does not count it", async () => {
 		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const counts = await reportProfileState(project, false);
-		expect(counts.unfixable).toBeGreaterThan(0);
-		expect(printed()).toContain("git rm --cached .claude/settings.json");
-		await untouched();
+		expect(counts.unfixable).toBe(0);
+		expect(printed()).toContain(`• ${WARNING}`);
 	});
 
-	test("review M1: writeSettings and writeMcpConfig refuse a tracked live file and leave it as it is", async () => {
+	test("B7: writeSettings and writeMcpConfig write a tracked live file", async () => {
 		await commitTrackedSettings();
 		await fs.outputJson(join(project, ".mcp.json"), { mcpServers: {} });
 		git(project, "add", ".mcp.json");
 		expect(git(project, "commit", "-q", "-m", "mcp").status).toBe(0);
-		const before = await fs.readFile(settingsPath(), "utf8");
 
 		// What the TUI Profiles tab's "apply predefined" does.
 		const settings = await readSettings(project);
-		(settings.enabledPlugins as Record<string, boolean>)["frontend@magus"] =
-			true;
-		await expect(writeSettings(settings, project)).rejects.toBeInstanceOf(
-			TrackedLiveFileError,
-		);
-		await expect(
-			writeMcpConfig({ mcpServers: { x: { command: "x" } } }, project),
-		).rejects.toBeInstanceOf(TrackedLiveFileError);
-
-		expect(await fs.readFile(settingsPath(), "utf8")).toBe(before);
-		await untouched();
-	});
-
-	test("review M1: a project-scope Claude CLI install or uninstall is refused before the CLI runs", async () => {
-		await commitTrackedSettings();
-		const cwd = process.cwd();
-		const pathBefore = process.env.PATH;
-		// git stays reachable; `claude` does not — were the refusal missing, the
-		// CLI could not run here and touch this machine's plugins anyway.
-		const gitDir = spawnSync("sh", ["-c", "command -v git"], {
-			encoding: "utf8",
-		}).stdout.trim();
-		process.env.PATH = gitDir.slice(0, gitDir.lastIndexOf("/"));
-		process.chdir(project);
-		try {
-			await expect(
-				installPlugin("dev@magus", "project"),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
-			await expect(
-				uninstallPlugin("dev@magus", "project", project),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
-		} finally {
-			process.chdir(cwd);
-			process.env.PATH = pathBefore;
-		}
-		await untouched();
-	});
-
-	test("review M1: a project without profiles writes its own settings.json as before", async () => {
-		await commitTrackedSettings();
-		await writeManifest({ version: 2, profiles: {} }, project);
-		const settings = await readSettings(project);
 		(settings.enabledPlugins as Record<string, boolean>)["frontend@magus"] =
 			true;
 		await writeSettings(settings, project);
+		await writeMcpConfig({ mcpServers: { x: { command: "x" } } }, project);
+
 		expect(
 			(await fs.readJson(settingsPath())).enabledPlugins["frontend@magus"],
 		).toBe(true);
+		expect((await fs.readJson(join(project, ".mcp.json"))).mcpServers).toEqual({
+			x: { command: "x" },
+		});
+		nothingStaged();
 	});
 
-	test("review 3a: inside a work tree git cannot read, activation refuses with git's own message", async () => {
+	test("B7: inside a work tree git cannot read, activation writes and says git could not be asked", async () => {
 		// A .git pointing at a repository that is not there: git exits 128.
 		await fs.outputFile(
 			join(project, ".git"),
 			`gitdir: ${join(project, "no-such-repository")}\n`,
 		);
 
-		const error = await activateProfile(MANIFEST, "team", project, {
+		const result = await activateProfile(MANIFEST, "team", project, {
 			onDisplace: () => {},
-		}).then(
-			() => null,
-			(e: unknown) => e,
+		});
+
+		expect(await fs.pathExists(settingsPath())).toBe(true);
+		expect(typeof result.tracked).toBe("string");
+		expect(activationNotes(result).join("\n")).toContain(
+			"magus could not check which files git tracks in this project",
 		);
+		expect((await prepareProfileState(project)).problems).toEqual([]);
+	});
 
-		expect(error).toBeInstanceOf(GitCheckError);
-		expect((error as Error).message).toContain("not a git repository");
-		expect((error as Error).message).toContain("Nothing was changed.");
-		expect(await fs.pathExists(settingsPath())).toBe(false);
-		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
-			false,
+	test("B7 review L3: converting an older layout where git cannot answer exits 1 with git's message, no stack trace", async () => {
+		// 7.4.1 layout, a listed skill linked: the conversion must ask git which
+		// skill folders the team committed. `--dry-run` skips the entry gate, so
+		// the error reaches the router's own handler.
+		const withSkill = structuredClone(MANIFEST);
+		(withSkill.profiles.team as { skills: unknown[] }).skills = [
+			{ name: "alpha", repo: "a/b", path: "skills/alpha" },
+		];
+		await writeManifest(withSkill, project);
+		const old = join(project, ".claude", "_profiles", "team");
+		await fs.outputFile(join(old, "skills", "alpha", "SKILL.md"), "# alpha\n");
+		await fs.outputJson(join(old, "settings.json"), {
+			enabledPlugins: { "dev@magus": true },
+		});
+		await fs.symlink("_profiles/team/settings.json", settingsPath());
+		await fs.symlink(
+			"_profiles/team/skills",
+			join(project, ".claude", "skills"),
+		);
+		await fs.outputFile(
+			join(project, ".git"),
+			`gitdir: ${join(project, "no-such-repository")}\n`,
+		);
+		const cwd = process.cwd();
+		process.chdir(project);
+		let outcome: Awaited<ReturnType<typeof route>>;
+		try {
+			outcome = await route(
+				["profile", "switch", "team", "--dry-run"],
+				"0.0.0-test",
+			);
+		} finally {
+			process.chdir(cwd);
+		}
+		expect(outcome.exitCode).toBe(1);
+		expect(printed()).toContain(
+			"magus could not check which files git tracks in this project. git said:",
 		);
-		const prep = await prepareProfileState(project);
-		expect(prep.refusal).toBeInstanceOf(GitCheckError);
 	});
 
-	test("review 3a: git missing is a refusal inside a work tree, and no check outside one", async () => {
+	test("git missing is an error inside a work tree, and no check outside one", async () => {
 		expect(git(project, "init", "-q").status).toBe(0);
 		const outside = await mkdtemp(join(tmpdir(), "no-git-"));
 		const pathBefore = process.env.PATH;

package/src/cli/bootstrap.ts

@@ -18,7 +18,6 @@ import {
 	type ActivationResult,
 	activateProfile,
 	activationNotes,
-	assertNoTrackedWriteTargets,
 	reportDisplaced,
 } from "../services/profile-activate.js";
 import {
@@ -84,9 +83,6 @@ async function writeAndActivate(
 	// their hand-written files went.
 	const rel = (p: string) => path.relative(projectPath, p);
 
-	// Before the manifest is written: adopting activates, and activating a
-	// project whose settings.json git tracks would take that file over.
-	await assertNoTrackedWriteTargets(projectPath);
 	await writeManifest(result.manifest, projectPath);
 	console.log(`✓ Wrote ${rel(getManifestPath(projectPath))}`);
 

package/src/cli/doctor.ts

@@ -46,7 +46,7 @@ import {
 	type RepoRootCache,
 	pickLoadedEntry,
 } from "../services/plugin-resolution.js";
-import { trackedGeneratedFiles } from "../services/profile-activate.js";
+import { trackedGeneratedWarnings } from "../services/profile-activate.js";
 import {
 	LIVE_FILE_KEYS,
 	liveKind,
@@ -67,10 +67,6 @@ import {
 	switchHint,
 } from "../services/profile-state.js";
 import { resolveAllProfiles } from "../services/resolver.js";
-import {
-	GitCheckError,
-	untrackCommand,
-} from "../services/tracked-live-files.js";
 import type {
 	ClaudeSettings,
 	InstalledPluginsRegistry,
@@ -556,21 +552,11 @@ export async function reportProfileState(
 		}
 	}
 
-	// A .gitignore entry does not untrack a file committed before it. Report
-	// only: magus never runs git rm.
-	let tracked: string[] = [];
-	try {
-		tracked = await trackedGeneratedFiles(projectPath);
-	} catch (error) {
-		if (!(error instanceof GitCheckError)) throw error;
-		console.log(`✗ ${error.message}`);
-		unfixable++;
-	}
-	for (const rel of tracked) {
-		console.log(
-			`✗ ${rel} is generated from profiles.json but tracked by git. Fix: \`${untrackCommand(rel)}\`, then commit.`,
-		);
-		unfixable++;
+	// A .gitignore entry does not untrack a file committed before it. A note
+	// with the fix, not a failure: magus writes the file all the same, and
+	// never runs git rm itself.
+	for (const line of await trackedGeneratedWarnings(projectPath)) {
+		console.log(`• ${line}`);
 	}
 	return { fixable, unfixable };
 }

package/src/cli/router.ts

@@ -8,7 +8,7 @@
 
 import type { ThemeMode } from "@opentui/core";
 import { SettingsParseError } from "../services/settings-file.js";
-import { LiveFileRefusal } from "../services/tracked-live-files.js";
+import { GitCheckError } from "../services/tracked-live-files.js";
 import { checkForUpdates } from "../services/version-check.js";
 import { type ThemeEnv, parseThemeWord } from "../ui/theme-resolve.js";
 import { profileGate, reportUnparseable } from "./bootstrap.js";
@@ -224,9 +224,10 @@ export async function route(
 			reportUnparseable(error);
 			return HANDLED(1);
 		}
-		// A live file git tracks (or git could not say): nothing was written,
-		// and the message says what to do. A refusal, not a crash.
-		if (error instanceof LiveFileRefusal) {
+		// git could not say what it tracks, and converting an older layout needs
+		// to know which skill folders the team committed. git's own message, not
+		// a stack trace.
+		if (error instanceof GitCheckError) {
 			console.error(error.message);
 			return HANDLED(1);
 		}

package/src/cli/update.ts

@@ -51,6 +51,7 @@ import {
 import {
 	recordRefetchedSkills,
 	trackFetchedSkills,
+	trackedGeneratedWarnings,
 	updatableSkills,
 } from "../services/profile-activate.js";
 import { activeProfile } from "../services/profile-live.js";
@@ -202,6 +203,12 @@ export async function runUpdateCommand(
 		return 1;
 	}
 
+	// A generated file git tracks is written like any other; say so once, with
+	// the fix. magus never runs git itself.
+	for (const line of await trackedGeneratedWarnings(projectPath)) {
+		console.log(warnLine(line));
+	}
+
 	// No active profile, no update: that is where plugin state is read from and
 	// where changes are written. Asked before the profile is resolved, so what
 	// the user activates here is what this run uses.

package/src/services/claude-cli.ts

@@ -10,7 +10,6 @@
  */
 
 import { execFile } from "node:child_process";
-import path from "node:path";
 import { promisify } from "node:util";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import { which } from "../utils/command-utils.js";
@@ -20,7 +19,6 @@ import {
 	removeLocalInstalledPluginVersion,
 } from "./claude-settings.js";
 import { removeInstalledPluginVersion } from "./plugin-manager.js";
-import { refuseTrackedLiveFiles } from "./tracked-live-files.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -140,23 +138,6 @@ async function execPluginCommand(
 	}
 }
 
-/**
- * Every `claude plugin … --scope project` command writes the project's
- * `.claude/settings.json` (its enabledPlugins entry). In a project with
- * profiles that file is generated; where git tracks it, refuse — before the
- * CLI runs — rather than let the CLI write it (see `tracked-live-files.ts`).
- * The CLI works on the current directory.
- */
-async function refuseProjectSettingsWrite(
-	scope: PluginScope,
-	projectPath: string = process.cwd(),
-): Promise<void> {
-	if (scope !== "project") return;
-	await refuseTrackedLiveFiles(projectPath, [
-		path.join(".claude", "settings.json"),
-	]);
-}
-
 /**
  * Install a plugin using claude CLI
  * Handles enabling + version tracking + cache copy in one shot.
@@ -173,7 +154,6 @@ export async function installPlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
-	await refuseProjectSettingsWrite(scope);
 	// 60s, matching update and repair. Before the install/update split this path
 	// ran through `updatePlugin`'s 60s budget; leaving it on the 30s default
 	// would have quietly halved the time a fresh install — the SLOWEST of the
@@ -192,7 +172,6 @@ export async function uninstallPlugin(
 	scope: PluginScope = "user",
 	projectPath?: string,
 ): Promise<void> {
-	await refuseProjectSettingsWrite(scope, projectPath);
 	try {
 		await execClaude(["plugin", "uninstall", pluginId, "--scope", scope]);
 	} catch {
@@ -245,7 +224,6 @@ export async function enablePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
-	await refuseProjectSettingsWrite(scope);
 	await execClaude(["plugin", "enable", pluginId, "--scope", scope]);
 }
 
@@ -256,7 +234,6 @@ export async function disablePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
-	await refuseProjectSettingsWrite(scope);
 	await execClaude(["plugin", "disable", pluginId, "--scope", scope]);
 }
 
@@ -299,7 +276,6 @@ export async function updatePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
-	await refuseProjectSettingsWrite(scope);
 	await execPluginCommand("update", pluginId, scope, 60000);
 }
 

package/src/services/claude-settings.ts

@@ -37,7 +37,6 @@ import {
 	writableList,
 	writableMap,
 } from "./settings-file.js";
-import { refuseTrackedLiveFiles } from "./tracked-live-files.js";
 
 /**
  * What every reader below throws for a file that exists but does not parse.
@@ -149,11 +148,6 @@ export async function writeSettings(
 	settings: ClaudeSettings,
 	projectPath?: string,
 ): Promise<void> {
-	// In a project with profiles this file is generated: never written where
-	// git tracks it (see `tracked-live-files.ts`).
-	await refuseTrackedLiveFiles(projectPath ?? process.cwd(), [
-		getSettingsPath(projectPath),
-	]);
 	await refuseUnwritableFile(getSettingsPath(projectPath));
 	const claudeDir = await ensureClaudeDir(projectPath);
 	const settingsPath = path.join(claudeDir, SETTINGS_FILE);
@@ -197,7 +191,6 @@ export async function writeMcpConfig(
 	projectPath?: string,
 ): Promise<void> {
 	const mcpPath = getMcpConfigPath(projectPath);
-	await refuseTrackedLiveFiles(projectPath ?? process.cwd(), [mcpPath]);
 	await refuseUnwritableFile(mcpPath);
 	await fs.writeJson(mcpPath, config, { spaces: 2 });
 }