magus-cli 7.10.4 → 7.10.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.10.4",
+  "version": "7.10.5",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.10.4",
-    "magus-cli-darwin-x64": "7.10.4",
-    "magus-cli-linux-x64": "7.10.4"
+    "magus-cli-darwin-arm64": "7.10.5",
+    "magus-cli-darwin-x64": "7.10.5",
+    "magus-cli-linux-x64": "7.10.5"
   }
 }

package/src/__tests__/profile-worktree-include.test.ts

@@ -0,0 +1,212 @@
+/**
+ * Claude Code copies git-ignored files into a NEW worktree (`claude -w`,
+ * EnterWorktree, agent isolation) only when the launch root's
+ * `.worktreeinclude` lists them. magus git-ignores the set-up state it
+ * generates, so it must also list that state there — or every new worktree of
+ * a profiled repo starts without the project's plugins.
+ *
+ * Exercised against a real git repository, with HOME and git config pointed at
+ * a scratch folder, because "listed AND git-ignored" is a statement about git.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { execFileSync, spawnSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { updateSkillIgnoreLines } from "../services/profile-skills.js";
+import {
+	inspectProfileState,
+	prepareProfileState,
+} from "../services/profile-state.js";
+import type { ProfileManifest } from "../types/index.js";
+
+// A profile with no plugins: activation renders the project's files with no
+// install, CLI call or network.
+const MANIFEST: ProfileManifest = {
+	version: 2,
+	profiles: { team: { name: "Team", plugins: {} } },
+	default: "team",
+};
+
+/** The set-up state a new worktree needs to start with the project's plugins. */
+const REQUIRED = [
+	".claude/settings.json",
+	".mcp.json",
+	".claude/models.json",
+	".claude/profiles/active.json",
+];
+
+const GIT_CFG = [
+	"-c",
+	"user.name=test",
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+const git = (cwd: string, ...args: string[]): string =>
+	execFileSync("git", [...GIT_CFG, ...args], {
+		cwd,
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+
+/** Whether git treats `rel` as ignored in `repo` (exit 0 = ignored). */
+const ignoredByGit = (repo: string, rel: string): boolean =>
+	spawnSync("git", [...GIT_CFG, "check-ignore", "-q", "--", rel], {
+		cwd: repo,
+	}).status === 0;
+
+const ENV_KEYS = [
+	"HOME",
+	"CLAUDE_CONFIG_DIR",
+	"XDG_CONFIG_HOME",
+	"XDG_CACHE_HOME",
+	"GIT_CONFIG_NOSYSTEM",
+	"GIT_CEILING_DIRECTORIES",
+	"GIT_DIR",
+	"GIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_COMMON_DIR",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_PREFIX",
+] as const;
+
+let savedEnv: Record<string, string | undefined> = {};
+let base: string;
+let project: string;
+let log: ReturnType<typeof spyOn>;
+let err: ReturnType<typeof spyOn>;
+
+const includePath = () => path.join(project, ".worktreeinclude");
+
+/** The non-blank, non-comment lines of `.worktreeinclude`. */
+async function includeLines(): Promise<string[]> {
+	const text = await fs.readFile(includePath(), "utf8");
+	return text
+		.split("\n")
+		.map((l) => l.trim())
+		.filter((l) => l !== "" && !l.startsWith("#"));
+}
+
+async function activate(): Promise<void> {
+	await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+}
+
+beforeEach(async () => {
+	savedEnv = {};
+	for (const key of ENV_KEYS) savedEnv[key] = process.env[key];
+	for (const key of ENV_KEYS) delete process.env[key];
+
+	base = await fs.realpath(
+		await fs.mkdtemp(path.join(os.tmpdir(), "magus-wt-include-")),
+	);
+	const home = path.join(base, "home");
+	await fs.ensureDir(path.join(home, ".claude"));
+	process.env.HOME = home;
+	process.env.XDG_CONFIG_HOME = path.join(home, ".config");
+	process.env.XDG_CACHE_HOME = path.join(home, ".cache");
+	process.env.CLAUDE_CONFIG_DIR = path.join(home, ".claude");
+	process.env.GIT_CONFIG_NOSYSTEM = "1";
+	process.env.GIT_CEILING_DIRECTORIES = base;
+
+	project = path.join(base, "repo");
+	await fs.ensureDir(project);
+	git(project, "init", "-q");
+	await writeManifest(MANIFEST, project);
+	git(project, "add", "-A");
+	git(project, "commit", "-qm", "manifest");
+
+	log = spyOn(console, "log").mockImplementation(() => {});
+	err = spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(async () => {
+	log.mockRestore();
+	err.mockRestore();
+	for (const key of ENV_KEYS) {
+		if (savedEnv[key] === undefined) delete process.env[key];
+		else process.env[key] = savedEnv[key];
+	}
+	await fs.remove(base);
+});
+
+describe("activation lists the set-up state in .worktreeinclude", () => {
+	test("lists every generated file and never the backups", async () => {
+		// REGRESSION: new git worktrees of a magus-profiled repo start without project plugins — Fixed in /dev:fix session dev-fix-20261015-002521-dc0f06b1
+		await activate();
+
+		expect(await fs.pathExists(includePath())).toBe(true);
+		const lines = await includeLines();
+		for (const entry of REQUIRED) expect(lines).toContain(entry);
+		expect(lines.some((l) => l.includes(".magus-backups"))).toBe(false);
+	});
+
+	test("every listed path is git-ignored, so Claude Code copies it", async () => {
+		// REGRESSION: new git worktrees of a magus-profiled repo start without project plugins — Fixed in /dev:fix session dev-fix-20261015-002521-dc0f06b1
+		await activate();
+
+		const lines = await includeLines();
+		expect(lines.length).toBeGreaterThan(0);
+		const notIgnored = lines.filter((l) => !ignoredByGit(project, l));
+		expect(notIgnored).toEqual([]);
+	});
+
+	test("a person's own .worktreeinclude lines survive activation untouched", async () => {
+		// REGRESSION: new git worktrees of a magus-profiled repo start without project plugins — Fixed in /dev:fix session dev-fix-20261015-002521-dc0f06b1
+		const own =
+			"# mine: local secrets for every worktree\n.env\nconfig/local.yaml\n";
+		await fs.writeFile(includePath(), own);
+
+		await activate();
+
+		const text = await fs.readFile(includePath(), "utf8");
+		expect(text.startsWith(own)).toBe(true);
+		const lines = await includeLines();
+		expect(lines).toContain(".env");
+		expect(lines).toContain("config/local.yaml");
+		for (const entry of REQUIRED) expect(lines).toContain(entry);
+	});
+});
+
+describe("an already set-up project gets the include on the next gate pass", () => {
+	test("inspectProfileState writes nothing; prepareProfileState adds the block", async () => {
+		// REGRESSION: new git worktrees of a magus-profiled repo start without project plugins — Fixed in /dev:fix session dev-fix-20261015-002521-dc0f06b1
+		await activate();
+		// A project set up by a release that never wrote the include.
+		await fs.remove(includePath());
+		expect(
+			await fs.pathExists(
+				path.join(project, ".claude", "profiles", "active.json"),
+			),
+		).toBe(true);
+
+		await inspectProfileState(project);
+		expect(await fs.pathExists(includePath())).toBe(false);
+
+		const prep = await prepareProfileState(project);
+		expect(prep.problems).toEqual([]);
+		expect(await fs.pathExists(includePath())).toBe(true);
+		const lines = await includeLines();
+		for (const entry of REQUIRED) expect(lines).toContain(entry);
+		expect(lines.some((l) => l.includes(".magus-backups"))).toBe(false);
+	});
+});
+
+describe("magus-installed skill folders follow the gitignore into the include", () => {
+	test("a recorded skill folder is listed, and unlisted when removed", async () => {
+		// REGRESSION: new git worktrees of a magus-profiled repo start without project plugins — Fixed in /dev:fix session dev-fix-20261015-002521-dc0f06b1
+		await updateSkillIgnoreLines(project, [], ["team-skill"]);
+		expect(await fs.pathExists(includePath())).toBe(true);
+		expect(await includeLines()).toContain(".claude/skills/team-skill/");
+
+		await updateSkillIgnoreLines(project, ["team-skill"], []);
+		expect(await includeLines()).not.toContain(".claude/skills/team-skill/");
+	});
+});

package/src/services/profile-activate.ts

@@ -42,6 +42,8 @@ import {
 	OBSOLETE_GITIGNORE_ENTRIES,
 	PROFILE_GITIGNORE_COMMENT,
 	PROFILE_GITIGNORE_ENTRIES,
+	PROFILE_WORKTREE_INCLUDE_COMMENT,
+	PROFILE_WORKTREE_INCLUDE_ENTRIES,
 	assertLiveFilesParse,
 	backupRoot,
 	backupStamp,
@@ -324,6 +326,13 @@ export async function activateProfile(
 			remove: conversion.converted ? OBSOLETE_GITIGNORE_ENTRIES : [],
 		},
 	);
+	// Claude Code copies git-ignored files into a worktree it creates only when
+	// `.worktreeinclude` lists them — see PROFILE_WORKTREE_INCLUDE_ENTRIES.
+	await updateManagedGitignoreBlock(
+		path.join(projectPath, ".worktreeinclude"),
+		PROFILE_WORKTREE_INCLUDE_COMMENT,
+		{ add: PROFILE_WORKTREE_INCLUDE_ENTRIES },
+	);
 
 	const backupDir = path.join(backupRoot(projectPath), backupStamp());
 	const displaced: DisplacedArtifact[] = [];

package/src/services/profile-live.ts

@@ -72,6 +72,32 @@ export const PROFILE_GITIGNORE_ENTRIES = [
 export const PROFILE_GITIGNORE_COMMENT =
 	"# magus: generated profile config (source of truth: .claude/profiles.json)";
 
+/**
+ * Paths magus lists in a project's `.worktreeinclude`. Claude Code copies a
+ * file into a worktree it creates (`claude -w`, EnterWorktree, agent
+ * isolation) only when that file is both git-ignored and listed there, at
+ * creation time. magus git-ignores the set-up state above, so without this
+ * list every new worktree gets `.claude/profiles.json` from the commit and none
+ * of the project's plugins.
+ *
+ * The marker FILE is listed, not `.claude/profiles/`: the directory would also
+ * copy a crash-orphaned temp file. It holds only hashes and ids, so a
+ * byte-for-byte copy reconciles as unchanged in the worktree. Backups are never
+ * listed — they are this checkout's hand-written files, possibly credentials,
+ * and nothing in a worktree uses them. Each magus-installed skill folder gets
+ * its own line (see `profile-skills.ts`).
+ */
+export const PROFILE_WORKTREE_INCLUDE_ENTRIES = [
+	".claude/settings.json",
+	".mcp.json",
+	".claude/models.json",
+	".claude/profiles/active.json",
+];
+
+/** The comment heading magus's lines in a project's `.worktreeinclude`. */
+export const PROFILE_WORKTREE_INCLUDE_COMMENT =
+	"# magus: copied into new worktrees so they start with this project's plugins (source of truth: .claude/profiles.json)";
+
 /**
  * Lines older releases wrote into magus's managed `.gitignore` block that must
  * go when an older layout is converted: the blanket skills ignore hid committed

package/src/services/profile-skills.ts

@@ -28,6 +28,7 @@ import type {
 import { updateManagedGitignoreBlock } from "./conventions-manager.js";
 import {
 	PROFILE_GITIGNORE_COMMENT,
+	PROFILE_WORKTREE_INCLUDE_COMMENT,
 	backupRoot,
 	backupStamp,
 	folderHash,
@@ -251,6 +252,9 @@ export async function inspectManagedSkills(
  * `.gitignore` block: `before` are the folders the marker listed, `after` the
  * ones it lists now. Lines are taken out of magus's block only — the same
  * pattern a person wrote elsewhere in the file stays.
+ *
+ * The same lines go into magus's `.worktreeinclude` block, so a worktree
+ * Claude Code creates gets the folders the copied marker records.
  */
 export async function updateSkillIgnoreLines(
 	projectPath: string,
@@ -258,13 +262,19 @@ export async function updateSkillIgnoreLines(
 	after: readonly string[],
 ): Promise<void> {
 	const keep = new Set(after);
+	const edits = {
+		add: [...keep].map(skillIgnoreLine),
+		remove: before.filter((f) => !keep.has(f)).map(skillIgnoreLine),
+	};
 	await updateManagedGitignoreBlock(
 		path.join(projectPath, ".gitignore"),
 		PROFILE_GITIGNORE_COMMENT,
-		{
-			add: [...keep].map(skillIgnoreLine),
-			remove: before.filter((f) => !keep.has(f)).map(skillIgnoreLine),
-		},
+		edits,
+	);
+	await updateManagedGitignoreBlock(
+		path.join(projectPath, ".worktreeinclude"),
+		PROFILE_WORKTREE_INCLUDE_COMMENT,
+		edits,
 	);
 }
 

package/src/services/profile-state.ts

@@ -28,6 +28,7 @@
 import path from "node:path";
 import type { ProfileManifest, ProfileManifestEntry } from "../types/index.js";
 import { selectProfileId } from "./active-closure.js";
+import { updateManagedGitignoreBlock } from "./conventions-manager.js";
 import { readManifest, updateProfileEntry, writeManifest } from "./manifest.js";
 import {
 	type ReconcileResult,
@@ -48,6 +49,8 @@ import {
 	type ActiveMarker,
 	LIVE_FILE_KEYS,
 	MACHINE_LOCAL_SETTINGS_KEYS,
+	PROFILE_WORKTREE_INCLUDE_COMMENT,
+	PROFILE_WORKTREE_INCLUDE_ENTRIES,
 	activeProfile,
 	folderHash,
 	hasCurrentMarker,
@@ -69,6 +72,7 @@ import {
 	SkillClashError,
 	inspectManagedSkills,
 	skillFolder,
+	skillIgnoreLine,
 } from "./profile-skills.js";
 import { resolveExtends } from "./resolver.js";
 import type { SettingsParseError } from "./settings-file.js";
@@ -371,6 +375,20 @@ export async function prepareProfileState(
 			out.lines.push(...activationNotes(result, { tracked: false }));
 			out.activations.push(result);
 		}
+		// A project set up by a release that never wrote `.worktreeinclude`
+		// re-activates rarely, so the gate lists the set-up state here. A no-op
+		// when every line is already there.
+		const marker = await readActiveMarker(projectPath);
+		await updateManagedGitignoreBlock(
+			path.join(projectPath, ".worktreeinclude"),
+			PROFILE_WORKTREE_INCLUDE_COMMENT,
+			{
+				add: [
+					...PROFILE_WORKTREE_INCLUDE_ENTRIES,
+					...Object.keys(marker?.skills ?? {}).map(skillIgnoreLine),
+				],
+			},
+		);
 		out.check = { state: "active", profile, restored: false };
 	}
 	return out;