magus-cli 7.5.2 → 7.5.3

package/src/services/gitignore-check.ts

@@ -1,63 +1,51 @@
 /**
- * Read-only gitignore check for the gitignore manager.
+ * The TUI's startup gitignore question.
  *
- * Called from the TUI on startup and from `doctor`. Resolves the manifest, runs
- * detection, and returns a concise warning when violations exist. Does NOT
- * auto-apply fixes — the user must open the Git State tab and confirm. This
- * mirrors the plugin-version-mismatch flow, where the check only *reports* and
- * the TUI provides the interactive fix dialog.
+ * Asked on every open (and again after a first adoption). Resolves the
+ * manifest — including, in a project with profiles, the files magus generates
+ * from `.claude/profiles.json` — runs detection, and reports. Nothing here
+ * applies a fix: the startup question applies the in-place fix only when the
+ * user picks it (`applyStartupFixes`), and every other destructive fix is
+ * confirmed per item in the Git State tab.
  */
 
 import type { Violation } from "../types/gitignore.js";
-import { detectViolations } from "./gitignore-detector.js";
-import { formatViolationSummary } from "./gitignore-fixer.js";
-import { resolveGitignore } from "./gitignore-resolver.js";
+import { loadGitignoreState } from "./gitignore-service.js";
 
-export interface GitignoreCheckResult {
+/** What the TUI's startup gitignore question needs to show. */
+export interface StartupGitignoreNeed {
 	violationCount: number;
-	warnings: string[];
-}
-
-export async function checkGitignore(
-	cwd: string,
-): Promise<GitignoreCheckResult> {
-	const warnings: string[] = [];
-	try {
-		const resolved = await resolveGitignore(cwd, {
-			logger: (m) => warnings.push(m),
-		});
-		const violations = await detectViolations(cwd, resolved);
-		return {
-			violationCount: violations.length,
-			warnings,
-		};
-	} catch (err) {
-		warnings.push(
-			`[gitignore] check failed: ${err instanceof Error ? err.message : String(err)}`,
-		);
-		return { violationCount: 0, warnings };
-	}
+	/** Missing `.gitignore` entries — the additive fix. */
+	safeCount: number;
+	/**
+	 * Files magus generates from `.claude/profiles.json` that git tracks — the
+	 * ones the startup fix untracks in place.
+	 */
+	generated: string[];
 }
 
 /**
- * One-line summary suitable for stderr. Returns null when there's
- * nothing to warn about.
+ * The startup gitignore question, or null when there is nothing to ask.
+ *
+ * Asked fresh on every call — the TUI calls it on every open, and again after
+ * a first adoption — and nothing remembers an earlier answer: a tracked
+ * generated file is asked about until it is fixed.
  */
-export function formatGitignoreWarning(
-	result: GitignoreCheckResult,
-): string | null {
-	if (result.violationCount === 0) return null;
-	return `⚠ ${result.violationCount} git state issue(s) detected. Run: magus → Git State tab to review and fix`;
+export async function startupGitignoreNeed(
+	cwd: string,
+): Promise<StartupGitignoreNeed | null> {
+	const { violations } = await loadGitignoreState(cwd);
+	if (violations.length === 0) return null;
+	return {
+		violationCount: violations.length,
+		safeCount: violations.filter((v) => v.severity === "safe").length,
+		generated: generatedTracked(violations).map((v) => v.path),
+	};
 }
 
-/**
- * Verbose multi-line summary, used by the Git State tab when the user wants
- * to know what's wrong before deciding what to do.
- */
-export async function describeViolations(
-	cwd: string,
-	violations: Violation[],
-): Promise<string> {
-	void cwd;
-	return formatViolationSummary(violations);
+/** The violations the startup fix handles in place: tracked generated files. */
+export function generatedTracked(violations: Violation[]): Violation[] {
+	return violations.filter(
+		(v) => v.kind === "tracked-but-should-ignore" && v.source === "profile",
+	);
 }

package/src/services/gitignore-resolver.ts

@@ -5,6 +5,10 @@
  *   1. Built-in defaults (shipped with magus)
  *   2. Global manifest at ~/.claude/gitignore.json (team-level, manually shared)
  *   3. Project manifest at <cwd>/.claude/gitignore.json
+ *   4. Profile: in a project with profiles, the files magus generates from
+ *      `.claude/profiles.json` (passed in as `opts.profile`). Highest, because
+ *      those files are rewritten per developer — tracking one cannot be right
+ *      whatever another manifest says.
  *
  * `extends` references are resolved against BUILTIN_TEMPLATES. Within a single
  * tier, the same pattern cannot appear in both `ignore` and `track` — that
@@ -33,9 +37,11 @@ export interface ResolveOptions {
 	homeDir?: string;
 	/** Optional logger for non-fatal warnings (malformed JSON, missing template). */
 	logger?: (msg: string) => void;
+	/** The profile tier — see `profileGitignoreManifest`. */
+	profile?: GitignoreManifest | null;
 }
 
-const TIER_ORDER: Tier[] = ["builtin", "global", "project"];
+const TIER_ORDER: Tier[] = ["builtin", "global", "project", "profile"];
 
 export async function resolveGitignore(
 	projectCwd: string,
@@ -59,6 +65,9 @@ export async function resolveGitignore(
 	const projectManifest = await readManifest(projectPath, log);
 	if (projectManifest) tierManifests.set("project", projectManifest);
 
+	// 4. The files the profile model generates
+	if (opts.profile) tierManifests.set("profile", opts.profile);
+
 	// Apply `extends` for each tier (templates count as part of their tier)
 	for (const tier of TIER_ORDER) {
 		const m = tierManifests.get(tier);

package/src/services/gitignore-service.ts

@@ -28,6 +28,7 @@ import {
 } from "./gitignore-fixer.js";
 import { resolveGitignore } from "./gitignore-resolver.js";
 import { readSettingsFile, writableList } from "./settings-file.js";
+import { profileGitignoreManifest } from "./tracked-live-files.js";
 
 export interface GitignoreState {
 	resolved: ResolvedManifest;
@@ -40,11 +41,77 @@ export async function loadGitignoreState(cwd: string): Promise<GitignoreState> {
 	const warnings: string[] = [];
 	const resolved = await resolveGitignore(cwd, {
 		logger: (m) => warnings.push(m),
+		profile: await profileGitignoreManifest(cwd),
 	});
 	const violations = await detectViolations(cwd, resolved);
 	return { resolved, violations, warnings };
 }
 
+export interface StartupFixResult {
+	/** Generated files removed from the index — staged, not committed. */
+	untracked: string[];
+	/** `.gitignore` entries added. */
+	appended: string[];
+	/** Files that could not be untracked, with git's reason. */
+	failed: Array<{ path: string; reason: string }>;
+}
+
+/**
+ * The startup question's fix, applied in place: every file magus generates
+ * from `.claude/profiles.json` that git tracks is removed from the index
+ * (`git rm --cached`, the existing tracked-but-should-ignore fix, which also
+ * makes sure `.gitignore` ignores it), and the additive `.gitignore` fixes
+ * are applied too. Every other violation is left for the Git State tab.
+ */
+export async function applyStartupFixes(
+	cwd: string,
+): Promise<StartupFixResult> {
+	const { resolved, violations } = await loadGitignoreState(cwd);
+	const generatedRules = resolved.rules
+		.filter((r) => r.source === "profile" && r.action === "ignore")
+		.map((r) => r.pattern);
+	const result: StartupFixResult = { untracked: [], appended: [], failed: [] };
+	for (const v of violations) {
+		if (v.kind !== "tracked-but-should-ignore" || v.source !== "profile") {
+			continue;
+		}
+		const rule =
+			generatedRules.find(
+				(p) => p === v.path || (p.endsWith("/") && v.path.startsWith(p)),
+			) ?? v.path;
+		try {
+			await coreApplyDestructiveFix(cwd, v, rule);
+			result.untracked.push(v.path);
+		} catch (error) {
+			result.failed.push({
+				path: v.path,
+				reason: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+	result.appended = (await coreApplySafeFixes(cwd, violations)).appended;
+	return result;
+}
+
+/** What {@link applyStartupFixes} did, for the message the TUI shows. */
+export function describeStartupFix(result: StartupFixResult): string {
+	const lines: string[] = [];
+	if (result.untracked.length > 0) {
+		lines.push(
+			"Stopped tracking (the removal is staged — commit it):",
+			...result.untracked.map((p) => `  ${p}`),
+			'  git commit -m "Stop tracking generated Claude Code config"',
+		);
+	}
+	if (result.appended.length > 0) {
+		lines.push("Added to .gitignore:", ...result.appended.map((p) => `  ${p}`));
+	}
+	for (const f of result.failed) {
+		lines.push(`Could not untrack ${f.path}: ${f.reason}`);
+	}
+	return lines.length > 0 ? lines.join("\n") : "Nothing needed changing.";
+}
+
 export async function applyAllSafeFixes(
 	cwd: string,
 	violations: Violation[],

package/src/services/profile-absorb.ts

@@ -61,8 +61,7 @@ import {
 	type ActivateOptions,
 	activateProfile,
 	activationNotes,
-	activeWritableSkillFolders,
-	writeRefusal,
+	releasedCommittedSkillNote,
 } from "./profile-activate.js";
 import {
 	type ActiveMarker,
@@ -94,6 +93,7 @@ import {
 } from "./profile-skills.js";
 import { resolveExtends, resolveProfile } from "./resolver.js";
 import { SettingsParseError } from "./settings-file.js";
+import { trackedSkillFolders } from "./tracked-live-files.js";
 
 // ─── Changes ─────────────────────────────────────────────────────────────────
 
@@ -1302,13 +1302,39 @@ export async function reconcileActiveProfile(
 	opts: ReconcileOptions = {},
 ): Promise<ReconcileResult> {
 	if (!(await hasCurrentMarker(projectPath))) return emptyResult(null);
-	const marker = await readActiveMarker(projectPath);
+	let marker = await readActiveMarker(projectPath);
 	if (!marker) return emptyResult(null);
 	const manifest = await readManifest(projectPath);
 	const current = manifest.profiles[marker.profile];
 	if (!current) return emptyResult(null);
 	const name = marker.profile;
 
+	// A recorded skill folder git tracks is the team's copy: 7.5.0's conversion
+	// recorded committed skills as magus-installed. Handed back — dropped from
+	// the marker, and from magus's ignore lines — before anything below could
+	// treat it as magus's to sync or remove, and said once.
+	const handedBackLines: string[] = [];
+	const handedBack = await trackedSkillFolders(
+		projectPath,
+		Object.keys(marker.skills),
+	);
+	if (handedBack.size > 0) {
+		const skills: Record<string, string> = {};
+		for (const [folder, hash] of Object.entries(marker.skills)) {
+			if (!handedBack.has(folder)) skills[folder] = hash;
+		}
+		await updateSkillIgnoreLines(
+			projectPath,
+			[...handedBack],
+			Object.keys(skills),
+		);
+		marker = { ...marker, skills };
+		await writeActiveMarker(marker, projectPath);
+		handedBackLines.push(
+			...[...handedBack].sort().map(releasedCommittedSkillNote),
+		);
+	}
+
 	const edited: LiveFileKey[] = [];
 	const missing: LiveFileKey[] = [];
 	for (const key of LIVE_FILE_KEYS) {
@@ -1343,23 +1369,11 @@ export async function reconcileActiveProfile(
 		!definitionChanged &&
 		!marker.cliBookkeeping
 	) {
-		return emptyResult(name);
+		return { ...emptyResult(name), lines: handedBackLines };
 	}
 
 	const result = emptyResult(name);
-
-	// Every write below lands in a live file, a skill folder the profile
-	// installs (or the manifest, on the way to one). None happens when git
-	// tracks one of them, or cannot say: see `tracked-live-files.ts`.
-	const refusal = await writeRefusal(
-		projectPath,
-		await activeWritableSkillFolders(projectPath, manifest),
-	);
-	if (refusal) {
-		result.problems.push(refusal.message);
-		result.lines.push(refusal.message);
-		return result;
-	}
+	result.lines.push(...handedBackLines);
 
 	// ── a. absorb ────────────────────────────────────────────────────────────
 	const base = marker.base ?? current;

package/src/services/profile-activate.ts

@@ -75,10 +75,10 @@ import {
 	updateSkillIgnoreLines,
 } from "./profile-skills.js";
 import {
-	LiveFileRefusal,
-	TrackedLiveFileError,
+	GitCheckError,
 	trackedPaths,
-	untrackCommand,
+	trackedSkillFolders,
+	trackedWarning,
 } from "./tracked-live-files.js";
 import type { ApplyReporter } from "./update-engine.js";
 
@@ -91,8 +91,12 @@ export interface ActivationResult {
 	skills: SkillSyncResult;
 	/** What converting an older layout did, if there was one. */
 	conversion: LegacySkillConversion;
-	/** Generated paths git still tracks (see {@link trackedGeneratedFiles}). */
-	tracked: string[];
+	/**
+	 * Generated paths git still tracks (see {@link trackedGeneratedFiles}) —
+	 * written all the same, and each warned about. A string instead when git
+	 * could not say (`GitCheckError`).
+	 */
+	tracked: string[] | string;
 	/** Where `.claude/_profiles/` was kept, project-relative, or null. */
 	keptAt: string | null;
 	/** Unsaved changes added to a profile before activating, one line each. */
@@ -101,6 +105,11 @@ export interface ActivationResult {
 	dependencies?: DependencyReport;
 	/** Listed skills whose folder the team committed: that copy is used. */
 	committedSkills?: string[];
+	/**
+	 * Skill folders the marker recorded as magus-installed that git tracks —
+	 * handed back to the team (see `releasedCommittedSkillNote`).
+	 */
+	releasedCommitted?: string[];
 }
 
 export interface ActivateOptions {
@@ -123,20 +132,19 @@ export function reportDisplaced(
 }
 
 /**
- * Generated paths that git tracks: the three live files, a committed
- * `.claude/skills` SYMLINK (an older layout committed by mistake), and any of
- * `skillFolders` — skill folders magus would install or remove. Committed
- * custom skills under a real `.claude/skills/` directory are not generated
- * state and are never reported. Empty outside a git repository.
+ * Generated files that git tracks: the three live files, and a committed
+ * `.claude/skills` SYMLINK (an older layout committed by mistake). A skill
+ * FOLDER git tracks is never one of them — it is the team's copy (see
+ * `trackedSkillFolders`). Empty outside a git repository; throws
+ * `GitCheckError` when git cannot say. Reported only — nothing refuses to
+ * write because of it (see `tracked-live-files.ts`).
  */
-export async function trackedWriteTargets(
+export async function trackedGeneratedFiles(
 	projectPath: string,
-	skillFolders: readonly string[] = [],
 ): Promise<string[]> {
 	const rel = (abs: string) => path.relative(projectPath, abs);
 	const live = LIVE_FILE_KEYS.map((key) => rel(livePath(key, projectPath)));
 	const skills = rel(skillsRoot(projectPath));
-	const folders = skillFolders.map((folder) => path.join(skills, folder));
 	let skillsIsLink = false;
 	try {
 		skillsIsLink = (await lstat(skillsRoot(projectPath))).isSymbolicLink();
@@ -144,112 +152,44 @@ export async function trackedWriteTargets(
 		// No .claude/skills at all.
 	}
 	const files = [...live, ...(skillsIsLink ? [skills] : [])];
-	const tracked = await trackedPaths(projectPath, files, folders);
-	return [...files, ...folders].filter((c) => tracked.has(c));
-}
-
-/**
- * The folders of `skills` the team committed under `.claude/skills/`. Such a
- * folder is the team's copy of the skill: magus neither installs over it nor
- * manages it, so it never has cause to suggest untracking it.
- */
-export async function committedSkillFolders(
-	projectPath: string,
-	skills: readonly ProfileSkillRef[],
-): Promise<Set<string>> {
-	const root = path.relative(projectPath, skillsRoot(projectPath));
-	const folders = skills.map((ref) => skillFolder(ref));
-	const tracked = await trackedPaths(
-		projectPath,
-		[],
-		folders.map((folder) => path.join(root, folder)),
-	);
-	return new Set(folders.filter((f) => tracked.has(path.join(root, f))));
-}
-
-/** {@link trackedWriteTargets} for the live files alone — what doctor reports. */
-export async function trackedGeneratedFiles(
-	projectPath: string,
-): Promise<string[]> {
-	return trackedWriteTargets(projectPath);
+	const tracked = await trackedPaths(projectPath, files);
+	return files.filter((c) => tracked.has(c));
 }
 
 /**
- * The skill folders activating a profile with `skills` could write: those
- * magus manages now (kept or removed), and the profile's that are not on disk
- * yet — unless the team committed them (see {@link committedSkillFolders}).
- * An existing folder magus does not manage is a custom skill, which
- * activation refuses as a clash rather than writing.
+ * {@link trackedGeneratedFiles} as the warning lines the CLI prints: one per
+ * tracked path, or one saying git could not be asked.
  */
-export async function writableSkillFolders(
+export async function trackedGeneratedWarnings(
 	projectPath: string,
-	skills: readonly ProfileSkillRef[],
-	managed: Readonly<Record<string, string>> = {},
 ): Promise<string[]> {
-	const out = new Set(Object.keys(managed));
-	const missing: ProfileSkillRef[] = [];
-	for (const ref of skills) {
-		const folder = skillFolder(ref);
-		if (out.has(folder)) continue;
-		try {
-			await lstat(path.join(skillsRoot(projectPath), folder));
-		} catch {
-			missing.push(ref);
-		}
-	}
-	const committed = await committedSkillFolders(projectPath, missing);
-	for (const ref of missing) {
-		if (!committed.has(skillFolder(ref))) out.add(skillFolder(ref));
+	try {
+		return (await trackedGeneratedFiles(projectPath)).map(trackedWarning);
+	} catch (error) {
+		if (error instanceof GitCheckError) return [error.message];
+		throw error;
 	}
-	return [...out];
 }
 
 /**
- * The skill folders the ACTIVE profile's next render could write — see
- * {@link writableSkillFolders}. For the checks made before a reconcile, which
- * may re-render and so install or remove them.
+ * The folders of `skills` the team committed under `.claude/skills/`. Such a
+ * folder is the team's copy of the skill: magus neither installs over it nor
+ * manages it, so it never has cause to suggest untracking it. None when git
+ * cannot say — each existing folder is then judged as a custom skill.
  */
-export async function activeWritableSkillFolders(
+export async function committedSkillFolders(
 	projectPath: string,
-	manifest: ProfileManifest,
-): Promise<string[]> {
-	const marker = await readActiveMarker(projectPath);
-	if (!marker) return [];
-	return writableSkillFolders(
+	skills: readonly ProfileSkillRef[],
+): Promise<Set<string>> {
+	return trackedSkillFolders(
 		projectPath,
-		manifest.profiles[marker.profile]?.skills ?? [],
-		marker.skills,
+		skills.map((ref) => skillFolder(ref)),
 	);
 }
 
-/**
- * Why magus must not write here, or null: {@link assertNoTrackedWriteTargets}
- * as a value, for callers that report a refusal instead of throwing it.
- */
-export async function writeRefusal(
-	projectPath: string,
-	skillFolders: readonly string[] = [],
-): Promise<LiveFileRefusal | null> {
-	try {
-		await assertNoTrackedWriteTargets(projectPath, skillFolders);
-		return null;
-	} catch (error) {
-		if (error instanceof LiveFileRefusal) return error;
-		throw error;
-	}
-}
-
-/**
- * Throw {@link TrackedLiveFileError} — before anything is written — when any
- * of {@link trackedWriteTargets} is tracked, or `GitCheckError` when git
- * cannot say.
- */
-export async function assertNoTrackedWriteTargets(
-	projectPath: string,
-	skillFolders: readonly string[] = [],
-): Promise<void> {
-	const tracked = await trackedWriteTargets(projectPath, skillFolders);
-	if (tracked.length > 0) throw new TrackedLiveFileError(tracked);
+/** The line for a recorded skill folder handed back to the team. */
+export function releasedCommittedSkillNote(folder: string): string {
+	return `Skill ${folder} is committed by the team — magus no longer manages it`;
 }
 
 /**
@@ -274,16 +214,16 @@ export function activationNotes(result: ActivationResult): string[] {
 	for (const f of result.skills.failed) {
 		lines.push(`Skill "${f.skill}" could not be installed: ${f.reason}`);
 	}
+	for (const folder of result.releasedCommitted ?? []) {
+		lines.push(releasedCommittedSkillNote(folder));
+	}
 	for (const folder of result.committedSkills ?? []) {
 		lines.push(
 			`Skill .claude/skills/${folder} is committed to git — the team's copy is used; magus does not install or manage it`,
 		);
 	}
-	for (const rel of result.tracked) {
-		lines.push(
-			`${rel} is generated but tracked by git — run \`${untrackCommand(rel)}\`, then commit`,
-		);
-	}
+	if (typeof result.tracked === "string") lines.push(result.tracked);
+	else lines.push(...result.tracked.map(trackedWarning));
 	if (result.keptAt) {
 		lines.push(
 			`The older layout's .claude/_profiles/ was kept at ${result.keptAt}/`,
@@ -295,9 +235,10 @@ export function activationNotes(result: ActivationResult): string[] {
 /**
  * Render `profileId` from `manifest` and make it the active profile.
  *
- * Throws {@link TrackedLiveFileError}, having changed nothing, when a path it
- * would write is tracked by git. Throws `SettingsParseError`, having changed
- * nothing, when a live file of a managed project does not parse. Throws
+ * A generated file git tracks is written like any other, and named in
+ * `tracked` so the caller can warn about it. Throws `SettingsParseError`,
+ * having changed nothing, when a live file of a managed project does not
+ * parse. Throws
  * {@link SkillClashError} — having
  * changed nothing but moving an older layout's skills into `.claude/skills/` —
  * when a listed skill's folder is already a custom skill.
@@ -315,21 +256,27 @@ export async function activateProfile(
 	// Read before converting: the older marker lives in the directory the
 	// conversion moves away, and an older layout is recognised by its links.
 	const previous = await readActiveMarker(projectPath);
-	// Before anything else is touched — the conversion below writes too.
-	await assertNoTrackedWriteTargets(
-		projectPath,
-		await writableSkillFolders(projectPath, skillRefs, previous?.skills),
-	);
 	const wasOldLayout = (await oldLayoutProfile(projectPath)) !== null;
 	// A managed project's live files are the profile's; one that does not
 	// parse is somebody mid-edit, and replacing it would lose their work. (At
 	// first adoption a hand-written file is moved to a backup, not replaced.)
 	if (previous !== null) await assertLiveFilesParse(projectPath);
 	const conversion = await convertLegacySkills(manifest, projectPath);
-	const managedBefore: Record<string, string> = {
+	const recorded: Record<string, string> = {
 		...(previous?.skills ?? {}),
 		...conversion.managed,
 	};
+	// A recorded folder git tracks is the team's copy — 7.5.0's conversion
+	// recorded committed skills as magus-installed. Dropped from the record
+	// here, before a sync could remove it, and said once.
+	const committedRecorded = await trackedSkillFolders(
+		projectPath,
+		Object.keys(recorded),
+	);
+	const managedBefore: Record<string, string> = {};
+	for (const [folder, hash] of Object.entries(recorded)) {
+		if (!committedRecorded.has(folder)) managedBefore[folder] = hash;
+	}
 
 	// Listed skills the team committed and magus does not manage: that copy
 	// stands, and magus neither installs over it nor reports it as a clash.
@@ -397,7 +344,7 @@ export async function activateProfile(
 	);
 	await updateSkillIgnoreLines(
 		projectPath,
-		Object.keys(managedBefore),
+		Object.keys(recorded),
 		Object.keys(skills.skills),
 	);
 	await writeActiveMarker(
@@ -412,7 +359,12 @@ export async function activateProfile(
 		displaced,
 		skills,
 		conversion,
-		tracked: await trackedGeneratedFiles(projectPath),
+		tracked: await trackedGeneratedFiles(projectPath).catch(
+			(error: unknown) => {
+				if (error instanceof GitCheckError) return error.message;
+				throw error;
+			},
+		),
 		keptAt: conversion.keptAt
 			? path.relative(projectPath, conversion.keptAt)
 			: null,
@@ -420,6 +372,9 @@ export async function activateProfile(
 		...(committedSkills.size > 0
 			? { committedSkills: [...committedSkills].sort() }
 			: {}),
+		...(committedRecorded.size > 0
+			? { releasedCommitted: [...committedRecorded].sort() }
+			: {}),
 	};
 }
 
@@ -445,7 +400,6 @@ export async function regenerateLiveFiles(
 	const marker = await readActiveMarker(projectPath);
 	const manifest = await readManifest(projectPath);
 	if (!marker || !manifest.profiles[marker.profile]) return false;
-	await assertNoTrackedWriteTargets(projectPath);
 	await assertLiveFilesParse(projectPath);
 	const rendered = await renderProfile(manifest, marker.profile, projectPath);
 	const files = await writeRenderedFiles(rendered, projectPath);