first-tree 0.0.6 → 0.0.8

package/dist/publish-D0crNDjz.js

@@ -0,0 +1,504 @@
+import { C as SKILL_ROOT, c as CLAUDE_INSTRUCTIONS_FILE, l as CLAUDE_SKILL_ROOT, n as Repo, r as AGENT_INSTRUCTIONS_FILE } from "./repo-BeVpMoHi.js";
+import { t as readBootstrapState } from "./bootstrap-YRjfHJp7.js";
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+//#region skills/first-tree/engine/publish.ts
+const PUBLISH_USAGE = `usage: context-tree publish [--open-pr] [--tree-path PATH] [--source-repo PATH] [--submodule-path PATH] [--source-remote NAME]
+
+Run this from the dedicated tree repo after \`context-tree init\`. The command
+creates or reuses the GitHub \`*-context\` repo, pushes the current tree
+commit, adds that repo back to the source/workspace repo as a git submodule,
+and prepares the source-repo branch.
+
+Options:
+  --open-pr               Open a PR in the source/workspace repo after pushing the branch
+  --tree-path PATH        Publish a tree repo from another working directory
+  --source-repo PATH      Explicit source/workspace repo path when it cannot be inferred
+  --submodule-path PATH   Path to use inside the source/workspace repo (default: tree repo name)
+  --source-remote NAME    Source/workspace repo remote to mirror on GitHub (default: origin)
+  --help                  Show this help message
+`;
+function defaultCommandRunner(command, args, options) {
+	try {
+		return execFileSync(command, args, {
+			cwd: options.cwd,
+			encoding: "utf-8",
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "unknown error";
+		throw new Error(`Command failed in ${options.cwd}: ${command} ${args.join(" ")}\n${message}`);
+	}
+}
+function commandSucceeds(runner, command, args, cwd) {
+	try {
+		runner(command, args, { cwd });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function parseGitHubRemote(url) {
+	if (url.startsWith("https://") || url.startsWith("http://")) try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "github.com") return null;
+		const parts = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/, "").split("/");
+		if (parts.length !== 2 || parts.some((part) => part.trim() === "")) return null;
+		return {
+			cloneStyle: "https",
+			owner: parts[0],
+			repo: parts[1],
+			slug: `${parts[0]}/${parts[1]}`
+		};
+	} catch {
+		return null;
+	}
+	if (url.startsWith("ssh://")) try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "github.com") return null;
+		const parts = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/, "").split("/");
+		if (parts.length !== 2 || parts.some((part) => part.trim() === "")) return null;
+		return {
+			cloneStyle: "ssh",
+			owner: parts[0],
+			repo: parts[1],
+			slug: `${parts[0]}/${parts[1]}`
+		};
+	} catch {
+		return null;
+	}
+	const scpMatch = url.match(/^git@github\.com:(.+?)\/(.+?)(?:\.git)?$/);
+	if (scpMatch === null) return null;
+	return {
+		cloneStyle: "ssh",
+		owner: scpMatch[1],
+		repo: scpMatch[2],
+		slug: `${scpMatch[1]}/${scpMatch[2]}`
+	};
+}
+function visibilityFlag(visibility) {
+	switch (visibility) {
+		case "internal": return "--internal";
+		case "private": return "--private";
+		default: return "--public";
+	}
+}
+function buildGitHubCloneUrl(slug, cloneStyle) {
+	if (cloneStyle === "ssh") return `git@github.com:${slug}.git`;
+	return `https://github.com/${slug}.git`;
+}
+function readGitHubRepoMetadata(runner, slug, cwd) {
+	const raw = runner("gh", [
+		"repo",
+		"view",
+		slug,
+		"--json",
+		"defaultBranchRef,nameWithOwner,visibility"
+	], { cwd });
+	const parsed = JSON.parse(raw);
+	const defaultBranch = parsed.defaultBranchRef?.name;
+	const nameWithOwner = parsed.nameWithOwner;
+	const visibility = parsed.visibility?.toLowerCase();
+	if (typeof defaultBranch !== "string" || typeof nameWithOwner !== "string" || visibility !== "internal" && visibility !== "private" && visibility !== "public") throw new Error(`Could not read GitHub metadata for ${slug}.`);
+	return {
+		defaultBranch,
+		nameWithOwner,
+		visibility
+	};
+}
+function readCurrentBranch(runner, root) {
+	return runner("git", ["branch", "--show-current"], { cwd: root }).trim();
+}
+function hasCommit(runner, root) {
+	return commandSucceeds(runner, "git", [
+		"rev-parse",
+		"--verify",
+		"HEAD"
+	], root);
+}
+function hasIndexedChanges(runner, root, paths) {
+	const args = [
+		"diff",
+		"--cached",
+		"--quiet"
+	];
+	if (paths && paths.length > 0) args.push("--", ...paths);
+	return !commandSucceeds(runner, "git", args, root);
+}
+function commitTreeState(runner, treeRepo) {
+	const hadCommit = hasCommit(runner, treeRepo.root);
+	runner("git", ["add", "-A"], { cwd: treeRepo.root });
+	if (!hasIndexedChanges(runner, treeRepo.root)) return false;
+	runner("git", [
+		"commit",
+		"-m",
+		hadCommit ? "chore: update context tree" : "chore: bootstrap context tree"
+	], { cwd: treeRepo.root });
+	return true;
+}
+function resolveSourceRepoRoot(treeRepo, options) {
+	const cwd = options?.currentCwd ?? process.cwd();
+	if (options?.sourceRepoPath) return resolve(cwd, options.sourceRepoPath);
+	const bootstrap = readBootstrapState(treeRepo.root);
+	if (bootstrap !== null) return resolve(treeRepo.root, bootstrap.sourceRepoPath);
+	if (treeRepo.repoName().endsWith("-context")) return join(dirname(treeRepo.root), treeRepo.repoName().slice(0, -8));
+	return null;
+}
+function normalizeSubmodulePath(input) {
+	if (input.trim() === "") return null;
+	if (isAbsolute(input)) return null;
+	const normalized = normalize(input).replaceAll("\\", "/");
+	if (normalized === "." || normalized === "" || normalized.startsWith("../") || normalized.includes("/../")) return null;
+	return normalized;
+}
+function getGitRemoteUrl(runner, root, remote) {
+	try {
+		return runner("git", [
+			"remote",
+			"get-url",
+			remote
+		], { cwd: root }).trim();
+	} catch {
+		return null;
+	}
+}
+function localBranchExists(runner, root, branch) {
+	return commandSucceeds(runner, "git", [
+		"rev-parse",
+		"--verify",
+		`refs/heads/${branch}`
+	], root);
+}
+function remoteTrackingBranchExists(runner, root, remote, branch) {
+	return commandSucceeds(runner, "git", [
+		"rev-parse",
+		"--verify",
+		`refs/remotes/${remote}/${branch}`
+	], root);
+}
+function buildPublishBranchName(treeRepoName) {
+	return `chore/connect-${treeRepoName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")}`;
+}
+function ensureSourceBranch(runner, sourceRepo, sourceRemote, defaultBranch, treeRepoName) {
+	const branch = buildPublishBranchName(treeRepoName);
+	if (readCurrentBranch(runner, sourceRepo.root) === branch) return branch;
+	if (localBranchExists(runner, sourceRepo.root, branch)) {
+		runner("git", ["switch", branch], { cwd: sourceRepo.root });
+		return branch;
+	}
+	if (!remoteTrackingBranchExists(runner, sourceRepo.root, sourceRemote, defaultBranch)) runner("git", [
+		"fetch",
+		sourceRemote,
+		defaultBranch
+	], { cwd: sourceRepo.root });
+	if (remoteTrackingBranchExists(runner, sourceRepo.root, sourceRemote, defaultBranch)) {
+		runner("git", [
+			"switch",
+			"-c",
+			branch,
+			"--track",
+			`${sourceRemote}/${defaultBranch}`
+		], { cwd: sourceRepo.root });
+		return branch;
+	}
+	runner("git", [
+		"switch",
+		"-c",
+		branch
+	], { cwd: sourceRepo.root });
+	return branch;
+}
+function isTrackedSubmodule(runner, sourceRoot, submodulePath) {
+	try {
+		return runner("git", [
+			"ls-files",
+			"--stage",
+			"--",
+			submodulePath
+		], { cwd: sourceRoot }).split(/\r?\n/).some((line) => line.startsWith("160000 "));
+	} catch {
+		return false;
+	}
+}
+function ensureSubmodule(runner, sourceRepo, submodulePath, remoteUrl) {
+	if (isTrackedSubmodule(runner, sourceRepo.root, submodulePath)) {
+		runner("git", [
+			"submodule",
+			"set-url",
+			"--",
+			submodulePath,
+			remoteUrl
+		], { cwd: sourceRepo.root });
+		runner("git", [
+			"submodule",
+			"sync",
+			"--",
+			submodulePath
+		], { cwd: sourceRepo.root });
+		runner("git", [
+			"submodule",
+			"update",
+			"--init",
+			"--",
+			submodulePath
+		], { cwd: sourceRepo.root });
+		return "updated";
+	}
+	if (existsSync(join(sourceRepo.root, submodulePath))) throw new Error(`Cannot add the submodule at ${submodulePath} because that path already exists in the source/workspace repo.`);
+	runner("git", [
+		"submodule",
+		"add",
+		remoteUrl,
+		submodulePath
+	], { cwd: sourceRepo.root });
+	return "added";
+}
+function commitSourceIntegration(runner, sourceRepo, submodulePath, treeRepoName) {
+	const managedPaths = [
+		...[
+			SKILL_ROOT,
+			CLAUDE_SKILL_ROOT,
+			AGENT_INSTRUCTIONS_FILE,
+			CLAUDE_INSTRUCTIONS_FILE
+		].filter((path) => existsSync(join(sourceRepo.root, path))),
+		".gitmodules",
+		submodulePath
+	].filter((path, index, items) => items.indexOf(path) === index);
+	runner("git", [
+		"add",
+		"--",
+		...managedPaths
+	], { cwd: sourceRepo.root });
+	if (!hasIndexedChanges(runner, sourceRepo.root, managedPaths)) return false;
+	runner("git", [
+		"commit",
+		"-m",
+		`chore: connect ${treeRepoName} context tree`,
+		"--",
+		...managedPaths
+	], { cwd: sourceRepo.root });
+	return true;
+}
+function ensureTreeRemotePublished(runner, treeRepo, treeSlug, sourceCloneStyle, visibility) {
+	const existingOrigin = getGitRemoteUrl(runner, treeRepo.root, "origin");
+	if (existingOrigin !== null) {
+		runner("git", [
+			"push",
+			"-u",
+			"origin",
+			"HEAD"
+		], { cwd: treeRepo.root });
+		return {
+			createdRemote: false,
+			remoteUrl: existingOrigin
+		};
+	}
+	const desiredCloneUrl = buildGitHubCloneUrl(treeSlug, sourceCloneStyle);
+	if (commandSucceeds(runner, "gh", [
+		"repo",
+		"view",
+		treeSlug,
+		"--json",
+		"nameWithOwner"
+	], treeRepo.root)) {
+		runner("git", [
+			"remote",
+			"add",
+			"origin",
+			desiredCloneUrl
+		], { cwd: treeRepo.root });
+		runner("git", [
+			"push",
+			"-u",
+			"origin",
+			"HEAD"
+		], { cwd: treeRepo.root });
+		return {
+			createdRemote: false,
+			remoteUrl: desiredCloneUrl
+		};
+	}
+	runner("gh", [
+		"repo",
+		"create",
+		treeSlug,
+		visibilityFlag(visibility),
+		"--source",
+		treeRepo.root,
+		"--remote",
+		"origin",
+		"--push"
+	], { cwd: treeRepo.root });
+	return {
+		createdRemote: true,
+		remoteUrl: getGitRemoteUrl(runner, treeRepo.root, "origin") ?? desiredCloneUrl
+	};
+}
+function buildPrBody(treeRepoName, treeSlug, submodulePath) {
+	return [
+		`Connect the published \`${treeRepoName}\` Context Tree back into this source/workspace repo.`,
+		"",
+		`- add \`${submodulePath}\` as the tracked Context Tree submodule`,
+		"- keep the local first-tree skill + source integration marker lines in this repo",
+		`- use \`${treeSlug}\` as the GitHub home for tree content`
+	].join("\n");
+}
+function parsePublishArgs(args) {
+	const parsed = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		switch (arg) {
+			case "--open-pr":
+				parsed.openPr = true;
+				break;
+			case "--tree-path": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --tree-path" };
+				parsed.treePath = value;
+				index += 1;
+				break;
+			}
+			case "--source-repo": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --source-repo" };
+				parsed.sourceRepoPath = value;
+				index += 1;
+				break;
+			}
+			case "--submodule-path": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --submodule-path" };
+				parsed.submodulePath = value;
+				index += 1;
+				break;
+			}
+			case "--source-remote": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --source-remote" };
+				parsed.sourceRemote = value;
+				index += 1;
+				break;
+			}
+			default: return { error: `Unknown publish option: ${arg}` };
+		}
+	}
+	return parsed;
+}
+function runPublish(repo, options) {
+	const cwd = options?.currentCwd ?? process.cwd();
+	const runner = options?.commandRunner ?? defaultCommandRunner;
+	const treeRepo = repo ?? new Repo(options?.treePath ? resolve(cwd, options.treePath) : void 0);
+	if (treeRepo.hasSourceWorkspaceIntegration() && !treeRepo.looksLikeTreeRepo()) {
+		console.error(`Error: this repo only has the first-tree source/workspace integration installed. Run \`context-tree publish --tree-path ../${treeRepo.repoName()}-context\` or switch into the dedicated tree repo first.`);
+		return 1;
+	}
+	if (!treeRepo.hasFramework() || !treeRepo.looksLikeTreeRepo()) {
+		console.error("Error: `context-tree publish` must run from a dedicated tree repo (or use `--tree-path` to point at one). Run `context-tree init` first.");
+		return 1;
+	}
+	const sourceRepoRoot = resolveSourceRepoRoot(treeRepo, options);
+	if (sourceRepoRoot === null) {
+		console.error("Error: could not determine the source/workspace repo for this tree. Re-run `context-tree init` from the source repo first, or pass `--source-repo PATH`.");
+		return 1;
+	}
+	const sourceRepo = new Repo(sourceRepoRoot);
+	if (!sourceRepo.isGitRepo()) {
+		console.error(`Error: the resolved source/workspace repo is not a git repository: ${sourceRepoRoot}`);
+		return 1;
+	}
+	if (sourceRepo.root === treeRepo.root) {
+		console.error("Error: the source/workspace repo and dedicated tree repo resolved to the same path. `context-tree publish` expects two separate repos.");
+		return 1;
+	}
+	if (!sourceRepo.hasCurrentInstalledSkill() || !sourceRepo.hasSourceWorkspaceIntegration()) {
+		console.error("Error: the source/workspace repo does not have the first-tree source integration installed. Run `context-tree init` from the source/workspace repo first.");
+		return 1;
+	}
+	const submodulePath = normalizeSubmodulePath(options?.submodulePath ?? treeRepo.repoName());
+	if (submodulePath === null) {
+		console.error("Error: `--submodule-path` must be a relative path inside the source/workspace repo.");
+		return 1;
+	}
+	const sourceRemoteName = options?.sourceRemote ?? "origin";
+	try {
+		console.log("Context Tree Publish\n");
+		console.log(`  Tree repo:   ${treeRepo.root}`);
+		console.log(`  Source repo: ${sourceRepo.root}\n`);
+		const sourceRemoteUrl = getGitRemoteUrl(runner, sourceRepo.root, sourceRemoteName);
+		if (sourceRemoteUrl === null) throw new Error(`Could not read git remote \`${sourceRemoteName}\` from the source/workspace repo.`);
+		const sourceGitHub = parseGitHubRemote(sourceRemoteUrl);
+		if (sourceGitHub === null) throw new Error(`The source/workspace remote \`${sourceRemoteName}\` is not a GitHub remote: ${sourceRemoteUrl}`);
+		const sourceMetadata = readGitHubRepoMetadata(runner, sourceGitHub.slug, sourceRepo.root);
+		const treeSlug = `${sourceGitHub.owner}/${treeRepo.repoName()}`;
+		if (commitTreeState(runner, treeRepo)) console.log("  Committed the current tree state.");
+		else console.log("  Tree repo already had a committed working state.");
+		const treeRemote = ensureTreeRemotePublished(runner, treeRepo, treeSlug, sourceGitHub.cloneStyle, sourceMetadata.visibility);
+		if (treeRemote.createdRemote) console.log(`  Created and pushed ${treeSlug}.`);
+		else console.log(`  Pushed the tree repo to ${treeRemote.remoteUrl}.`);
+		const sourceBranch = ensureSourceBranch(runner, sourceRepo, sourceRemoteName, sourceMetadata.defaultBranch, treeRepo.repoName());
+		console.log(`  Working on source/workspace branch \`${sourceBranch}\`.`);
+		const submoduleAction = ensureSubmodule(runner, sourceRepo, submodulePath, treeRemote.remoteUrl);
+		console.log(submoduleAction === "added" ? `  Added \`${submodulePath}\` as a git submodule.` : `  Updated the \`${submodulePath}\` submodule URL and checkout.`);
+		const committedSourceChanges = commitSourceIntegration(runner, sourceRepo, submodulePath, treeRepo.repoName());
+		if (committedSourceChanges) console.log("  Committed the source/workspace integration branch.");
+		else console.log("  Source/workspace integration was already up to date; no new commit was needed.");
+		if (committedSourceChanges || options?.openPr) {
+			runner("git", [
+				"push",
+				"-u",
+				sourceRemoteName,
+				sourceBranch
+			], { cwd: sourceRepo.root });
+			console.log(`  Pushed \`${sourceBranch}\` to \`${sourceRemoteName}\`.`);
+		}
+		if (options?.openPr) {
+			const prUrl = runner("gh", [
+				"pr",
+				"create",
+				"--repo",
+				sourceMetadata.nameWithOwner,
+				"--base",
+				sourceMetadata.defaultBranch,
+				"--head",
+				sourceBranch,
+				"--title",
+				`chore: connect ${treeRepo.repoName()} context tree`,
+				"--body",
+				buildPrBody(treeRepo.repoName(), treeSlug, submodulePath)
+			], { cwd: sourceRepo.root });
+			console.log(`  Opened PR: ${prUrl}`);
+		}
+		console.log();
+		console.log(`The source/workspace repo's \`${submodulePath}\` checkout is now the canonical local working copy for this tree.`);
+		console.log(`You can delete the temporary bootstrap checkout at ${treeRepo.root} once you no longer need it.`);
+		return 0;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "unknown error";
+		console.error(`Error: ${message}`);
+		return 1;
+	}
+}
+function runPublishCli(args = []) {
+	if (args.includes("--help") || args.includes("-h")) {
+		console.log(PUBLISH_USAGE);
+		return 0;
+	}
+	const parsed = parsePublishArgs(args);
+	if ("error" in parsed) {
+		console.error(parsed.error);
+		console.log(PUBLISH_USAGE);
+		return 1;
+	}
+	return runPublish(void 0, parsed);
+}
+//#endregion
+export { runPublishCli as runPublish };

package/dist/{repo-Cc5U4DWT.js → repo-BeVpMoHi.js}

@@ -17,6 +17,7 @@ join(FRAMEWORK_ASSET_ROOT, "prompts");
 const FRAMEWORK_EXAMPLES_DIR = join(FRAMEWORK_ASSET_ROOT, "examples");
 join(FRAMEWORK_ASSET_ROOT, "helpers");
 const INSTALLED_PROGRESS = join(SKILL_ROOT, "progress.md");
+const BOOTSTRAP_STATE = join(SKILL_ROOT, "bootstrap.json");
 const AGENT_INSTRUCTIONS_FILE = "AGENTS.md";
 const LEGACY_AGENT_INSTRUCTIONS_FILE = "AGENT.md";
 const AGENT_INSTRUCTIONS_TEMPLATE = "agents.md.template";
@@ -46,15 +47,6 @@ join(LEGACY_REPO_SKILL_ASSET_ROOT, "prompts");
 const LEGACY_REPO_SKILL_EXAMPLES_DIR = join(LEGACY_REPO_SKILL_ASSET_ROOT, "examples");
 join(LEGACY_REPO_SKILL_ASSET_ROOT, "helpers");
 const LEGACY_REPO_SKILL_PROGRESS = join(LEGACY_REPO_SKILL_ROOT, "progress.md");
-const LEGACY_SKILL_NAME = "first-tree-cli-framework";
-const LEGACY_SKILL_ROOT = join("skills", LEGACY_SKILL_NAME);
-const LEGACY_SKILL_ASSET_ROOT = join(LEGACY_SKILL_ROOT, "assets", "framework");
-const LEGACY_SKILL_VERSION = join(LEGACY_SKILL_ASSET_ROOT, "VERSION");
-join(LEGACY_SKILL_ASSET_ROOT, "templates");
-join(LEGACY_SKILL_ASSET_ROOT, "workflows");
-join(LEGACY_SKILL_ASSET_ROOT, "prompts");
-const LEGACY_SKILL_EXAMPLES_DIR = join(LEGACY_SKILL_ASSET_ROOT, "examples");
-const LEGACY_SKILL_PROGRESS = join(LEGACY_SKILL_ROOT, "progress.md");
 const LEGACY_FRAMEWORK_ROOT = ".context-tree";
 const LEGACY_VERSION = join(LEGACY_FRAMEWORK_ROOT, "VERSION");
 const LEGACY_PROGRESS = join(LEGACY_FRAMEWORK_ROOT, "progress.md");
@@ -81,7 +73,6 @@ function frameworkVersionCandidates() {
 		FRAMEWORK_VERSION,
 		CLAUDE_FRAMEWORK_VERSION,
 		LEGACY_REPO_SKILL_VERSION,
-		LEGACY_SKILL_VERSION,
 		LEGACY_VERSION
 	];
 }
@@ -90,7 +81,6 @@ function progressFileCandidates() {
 		INSTALLED_PROGRESS,
 		CLAUDE_INSTALLED_PROGRESS,
 		LEGACY_REPO_SKILL_PROGRESS,
-		LEGACY_SKILL_PROGRESS,
 		LEGACY_PROGRESS
 	];
 }
@@ -105,7 +95,6 @@ function detectFrameworkLayout(root) {
 	if (pathExists(root, FRAMEWORK_VERSION)) return "skill";
 	if (pathExists(root, CLAUDE_FRAMEWORK_VERSION)) return "claude-skill";
 	if (pathExists(root, LEGACY_REPO_SKILL_VERSION)) return "legacy-repo-skill";
-	if (pathExists(root, LEGACY_SKILL_VERSION)) return "legacy-skill";
 	if (pathExists(root, LEGACY_VERSION)) return "legacy";
 	return null;
 }
@@ -261,7 +250,6 @@ var Repo = class {
 	preferredProgressPath() {
 		const layout = this.frameworkLayout();
 		if (layout === "legacy") return LEGACY_PROGRESS;
-		if (layout === "legacy-skill") return LEGACY_SKILL_PROGRESS;
 		if (layout === "legacy-repo-skill") return LEGACY_REPO_SKILL_PROGRESS;
 		if (layout === "claude-skill") return CLAUDE_INSTALLED_PROGRESS;
 		return INSTALLED_PROGRESS;
@@ -269,7 +257,6 @@ var Repo = class {
 	frameworkVersionPath() {
 		const layout = this.frameworkLayout();
 		if (layout === "legacy") return LEGACY_VERSION;
-		if (layout === "legacy-skill") return LEGACY_SKILL_VERSION;
 		if (layout === "legacy-repo-skill") return LEGACY_REPO_SKILL_VERSION;
 		if (layout === "claude-skill") return CLAUDE_FRAMEWORK_VERSION;
 		return FRAMEWORK_VERSION;
@@ -386,4 +373,4 @@ function isDirectory(root, relPath) {
 	}
 }
 //#endregion
-export { LEGACY_SKILL_ROOT as C, SOURCE_INTEGRATION_MARKER as D, SOURCE_INTEGRATION_FILES as E, installedSkillRootsDisplay as O, LEGACY_SKILL_NAME as S, SKILL_ROOT as T, LEGACY_EXAMPLES_DIR as _, BUNDLED_SKILL_ROOT as a, LEGACY_REPO_SKILL_ROOT as b, CLAUDE_SKILL_ROOT as c, FRAMEWORK_TEMPLATES_DIR as d, FRAMEWORK_VERSION as f, LEGACY_AGENT_INSTRUCTIONS_FILE as g, INSTALLED_SKILL_ROOTS as h, AGENT_INSTRUCTIONS_TEMPLATE as i, FRAMEWORK_ASSET_ROOT as l, INSTALLED_PROGRESS as m, Repo as n, CLAUDE_FRAMEWORK_EXAMPLES_DIR as o, FRAMEWORK_WORKFLOWS_DIR as p, AGENT_INSTRUCTIONS_FILE as r, CLAUDE_INSTRUCTIONS_FILE as s, FRAMEWORK_END_MARKER as t, FRAMEWORK_EXAMPLES_DIR as u, LEGACY_FRAMEWORK_ROOT as v, SKILL_NAME as w, LEGACY_SKILL_EXAMPLES_DIR as x, LEGACY_REPO_SKILL_EXAMPLES_DIR as y };
+export { SKILL_ROOT as C, installedSkillRootsDisplay as E, SKILL_NAME as S, SOURCE_INTEGRATION_MARKER as T, LEGACY_AGENT_INSTRUCTIONS_FILE as _, BOOTSTRAP_STATE as a, LEGACY_REPO_SKILL_EXAMPLES_DIR as b, CLAUDE_INSTRUCTIONS_FILE as c, FRAMEWORK_EXAMPLES_DIR as d, FRAMEWORK_TEMPLATES_DIR as f, INSTALLED_SKILL_ROOTS as g, INSTALLED_PROGRESS as h, AGENT_INSTRUCTIONS_TEMPLATE as i, CLAUDE_SKILL_ROOT as l, FRAMEWORK_WORKFLOWS_DIR as m, Repo as n, BUNDLED_SKILL_ROOT as o, FRAMEWORK_VERSION as p, AGENT_INSTRUCTIONS_FILE as r, CLAUDE_FRAMEWORK_EXAMPLES_DIR as s, FRAMEWORK_END_MARKER as t, FRAMEWORK_ASSET_ROOT as u, LEGACY_EXAMPLES_DIR as v, SOURCE_INTEGRATION_FILES as w, LEGACY_REPO_SKILL_ROOT as x, LEGACY_FRAMEWORK_ROOT as y };

package/dist/{source-integration-CuKjoheT.js → source-integration-DMxnl8Dw.js}

@@ -1,4 +1,4 @@
-import { C as LEGACY_SKILL_ROOT, D as SOURCE_INTEGRATION_MARKER, E as SOURCE_INTEGRATION_FILES, a as BUNDLED_SKILL_ROOT, b as LEGACY_REPO_SKILL_ROOT, h as INSTALLED_SKILL_ROOTS } from "./repo-Cc5U4DWT.js";
+import { T as SOURCE_INTEGRATION_MARKER, g as INSTALLED_SKILL_ROOTS, o as BUNDLED_SKILL_ROOT, w as SOURCE_INTEGRATION_FILES, x as LEGACY_REPO_SKILL_ROOT } from "./repo-BeVpMoHi.js";
 import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
@@ -22,11 +22,7 @@ function resolveCanonicalSkillRoot(sourceRoot) {
 }
 function copyCanonicalSkill(sourceRoot, targetRoot) {
 	const src = resolveCanonicalSkillRoot(sourceRoot);
-	for (const relPath of [
-		...INSTALLED_SKILL_ROOTS,
-		LEGACY_REPO_SKILL_ROOT,
-		LEGACY_SKILL_ROOT
-	]) {
+	for (const relPath of [...INSTALLED_SKILL_ROOTS, LEGACY_REPO_SKILL_ROOT]) {
 		const fullPath = join(targetRoot, relPath);
 		if (existsSync(fullPath)) rmSync(fullPath, {
 			recursive: true,

package/dist/{upgrade-BvA9oKmi.js → upgrade-B_NTlNrx.js}

@@ -1,5 +1,5 @@
-import { C as LEGACY_SKILL_ROOT, D as SOURCE_INTEGRATION_MARKER, O as installedSkillRootsDisplay, T as SKILL_ROOT, b as LEGACY_REPO_SKILL_ROOT, c as CLAUDE_SKILL_ROOT, d as FRAMEWORK_TEMPLATES_DIR, f as FRAMEWORK_VERSION, g as LEGACY_AGENT_INSTRUCTIONS_FILE, i as AGENT_INSTRUCTIONS_TEMPLATE, m as INSTALLED_PROGRESS, n as Repo, p as FRAMEWORK_WORKFLOWS_DIR, r as AGENT_INSTRUCTIONS_FILE, s as CLAUDE_INSTRUCTIONS_FILE, v as LEGACY_FRAMEWORK_ROOT } from "./repo-Cc5U4DWT.js";
-import { a as resolveCanonicalSkillRoot, i as resolveBundledPackageRoot, n as copyCanonicalSkill, t as upsertSourceIntegrationFiles } from "./source-integration-CuKjoheT.js";
+import { C as SKILL_ROOT, E as installedSkillRootsDisplay, T as SOURCE_INTEGRATION_MARKER, _ as LEGACY_AGENT_INSTRUCTIONS_FILE, c as CLAUDE_INSTRUCTIONS_FILE, f as FRAMEWORK_TEMPLATES_DIR, h as INSTALLED_PROGRESS, i as AGENT_INSTRUCTIONS_TEMPLATE, l as CLAUDE_SKILL_ROOT, m as FRAMEWORK_WORKFLOWS_DIR, n as Repo, p as FRAMEWORK_VERSION, r as AGENT_INSTRUCTIONS_FILE, x as LEGACY_REPO_SKILL_ROOT, y as LEGACY_FRAMEWORK_ROOT } from "./repo-BeVpMoHi.js";
+import { a as resolveCanonicalSkillRoot, i as resolveBundledPackageRoot, n as copyCanonicalSkill, t as upsertSourceIntegrationFiles } from "./source-integration-DMxnl8Dw.js";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 //#region skills/first-tree/engine/runtime/upgrader.ts
@@ -46,7 +46,6 @@ function formatUpgradeTaskList(repo, localVersion, packagedVersion, layout) {
 	const migrationTasks = [];
 	if (layout === "legacy") migrationTasks.push("- [ ] Remove any stale `.context-tree/` references from repo-specific docs, scripts, or workflow files");
 	if (layout === "legacy-repo-skill") lines.push("## Migration", `- [ ] Remove any stale \`${LEGACY_REPO_SKILL_ROOT}/\` references from repo-specific docs, scripts, workflow files, or agent config`, "");
-	if (layout === "legacy-skill") migrationTasks.push(`- [ ] Remove any stale \`${LEGACY_SKILL_ROOT}/\` references from repo-specific docs, scripts, workflow files, or agent config`);
 	if (repo.hasCanonicalAgentInstructionsFile() && repo.hasLegacyAgentInstructionsFile()) migrationTasks.push(`- [ ] Merge any remaining user-authored content from \`${LEGACY_AGENT_INSTRUCTIONS_FILE}\` into \`${AGENT_INSTRUCTIONS_FILE}\`, then delete the legacy file`);
 	else if (repo.hasLegacyAgentInstructionsFile()) migrationTasks.push(`- [ ] Rename \`${LEGACY_AGENT_INSTRUCTIONS_FILE}\` to \`${AGENT_INSTRUCTIONS_FILE}\` to use the canonical agent instructions filename`);
 	if (migrationTasks.length > 0) lines.push("## Migration", ...migrationTasks, "");
@@ -125,7 +124,6 @@ function runUpgrade(repo, options) {
 		});
 		console.log(`Migrated legacy .context-tree/ layout to ${installedSkillRootsDisplay()}.`);
 	} else if (layout === "legacy-repo-skill") console.log(`Migrated legacy ${LEGACY_REPO_SKILL_ROOT}/ layout to ${installedSkillRootsDisplay()}.`);
-	else if (layout === "legacy-skill") console.log(`Migrated ${LEGACY_SKILL_ROOT}/ to ${installedSkillRootsDisplay()}.`);
 	else if (missingInstalledRoots.length > 0) console.log(`Repaired missing installed skill roots (${missingInstalledRoots.map((root) => `${root}/`).join(", ")}) and refreshed ${installedSkillRootsDisplay()} from the bundled first-tree package.`);
 	else console.log(`Refreshed ${installedSkillRootsDisplay()} from the bundled first-tree package.`);
 	const output = formatUpgradeTaskList(workingRepo, localVersion, packagedVersion, layout);

package/dist/{verify-G8gNXzDX.js → verify-Chhm1vOF.js}

@@ -1,4 +1,4 @@
-import { C as LEGACY_SKILL_ROOT, T as SKILL_ROOT, g as LEGACY_AGENT_INSTRUCTIONS_FILE, n as Repo, r as AGENT_INSTRUCTIONS_FILE } from "./repo-Cc5U4DWT.js";
+import { C as SKILL_ROOT, S as SKILL_NAME, _ as LEGACY_AGENT_INSTRUCTIONS_FILE, n as Repo, r as AGENT_INSTRUCTIONS_FILE } from "./repo-BeVpMoHi.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 //#region skills/first-tree/engine/validators/members.ts
@@ -186,14 +186,14 @@ function rel(path) {
 	return relative(treeRoot, path);
 }
 function isInstalledSkillPath(relPath) {
-	return relPath === SKILL_ROOT || relPath.startsWith(`${SKILL_ROOT}/`) || relPath === LEGACY_SKILL_ROOT || relPath.startsWith(`${LEGACY_SKILL_ROOT}/`);
+	return relPath === SKILL_ROOT || relPath.startsWith(`${SKILL_ROOT}/`);
 }
 function isFrameworkContainerDir(relPath, fullPath) {
 	if (relPath !== "skills") return false;
 	try {
 		const entries = readdirSync(fullPath).filter((entry) => !entry.startsWith("."));
 		if (entries.length === 0) return false;
-		return entries.every((entry) => entry === "first-tree" || entry === "first-tree-cli-framework");
+		return entries.every((entry) => entry === SKILL_NAME);
 	} catch {
 		return false;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "first-tree",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "CLI tools for Context Tree — the living source of truth for your organization.",
   "homepage": "https://github.com/agent-team-foundation/first-tree#readme",
   "bugs": {