first-tree 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,68 @@
+# seed-tree
+
+Template source and CLI for [Context Tree](https://context-tree.ai) — the living source of truth for your organization.
+
+## What is Context Tree?
+
+A tree-structured knowledge base that agents and humans build and maintain together. Every node represents a domain, decision, or design. Every node has an owner. When things change, the tree updates. See [docs/about.md](docs/about.md) for the full story.
+
+## Quick Start
+
+```bash
+npx context-tree init
+```
+
+Run this inside a git repo. It clones the framework, renders scaffolding, and generates a task list for your agent to work through.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `context-tree init` | Bootstrap a new context tree in the current git repo |
+| `context-tree verify` | Run checks against the tree, report pass/fail |
+| `context-tree upgrade` | Compare local framework version to upstream, generate upgrade tasks |
+
+## What `init` creates
+
+```
+your-tree/
+  .context-tree/           # framework (upgradable from seed-tree)
+    VERSION
+    principles.md
+    ownership-and-naming.md
+    templates/
+    workflows/
+    examples/
+  NODE.md                  # root node — your domains (from template)
+  AGENT.md                 # agent instructions with framework markers (from template)
+  members/
+    NODE.md                # members domain (from template)
+```
+
+## Upgrades
+
+After init, seed-tree is added as a git remote (`context-tree-upstream`). To upgrade the framework:
+
+```bash
+context-tree upgrade      # shows what changed and what to do
+```
+
+## Documentation
+
+- [docs/onboarding.md](docs/onboarding.md) — Onboarding guide for setting up a context tree (for agents)
+- [docs/about.md](docs/about.md) — What is Context Tree and who it's for
+- [.context-tree/principles.md](.context-tree/principles.md) — Core principles with examples
+- [.context-tree/ownership-and-naming.md](.context-tree/ownership-and-naming.md) — Node naming and ownership model
+
+## Development
+
+```bash
+pnpm install
+pnpm test              # run tests
+pnpm typecheck         # type check
+pnpm build             # build CLI
+```
+
+## License
+
+Apache 2.0

package/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+//#region src/cli.ts
+const USAGE = `usage: context-tree <command>
+
+Commands:
+  init      Bootstrap a new context tree (clones seed-tree, copies framework files)
+  verify    Run verification checks against the current tree
+  upgrade   Generate an upgrade task list from upstream changes
+
+Options:
+  --help    Show this help message
+`;
+async function main() {
+	const args = process.argv.slice(2);
+	if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+		console.log(USAGE);
+		return 0;
+	}
+	const command = args[0];
+	switch (command) {
+		case "init": {
+			const { runInit } = await import("./init-CE_944sb.js");
+			return runInit();
+		}
+		case "verify": {
+			const { runVerify } = await import("./verify-DIz6qmBX.js");
+			return runVerify();
+		}
+		case "upgrade": {
+			const { runUpgrade } = await import("./upgrade-Chr7z0CY.js");
+			return runUpgrade();
+		}
+		default:
+			console.log(`Unknown command: ${command}`);
+			console.log(USAGE);
+			return 1;
+	}
+}
+main().then((code) => process.exit(code));
+//#endregion
+export {};

package/dist/init-CE_944sb.js

@@ -0,0 +1,283 @@
+import { n as Repo, t as FRAMEWORK_END_MARKER } from "./repo-BByc3VvM.js";
+import { execFileSync } from "node:child_process";
+import { copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/rules/agent-instructions.ts
+var agent_instructions_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$5 });
+function evaluate$5(repo) {
+	const tasks = [];
+	if (!repo.pathExists("AGENT.md")) tasks.push("AGENT.md is missing — create from `.context-tree/templates/agent.md.template`");
+	else if (!repo.hasAgentMdMarkers()) tasks.push("AGENT.md exists but is missing framework markers — add `<!-- BEGIN CONTEXT-TREE FRAMEWORK -->` and `<!-- END CONTEXT-TREE FRAMEWORK -->` sections");
+	else {
+		const afterMarker = (repo.readFile("AGENT.md") ?? "").split(FRAMEWORK_END_MARKER);
+		if (afterMarker.length > 1) {
+			if (afterMarker[1].trim().split("\n").filter((l) => l.trim() && !l.trim().startsWith("#") && !l.trim().startsWith("<!--")).length === 0) tasks.push("Add your project-specific instructions below the framework markers in AGENT.md");
+		}
+	}
+	return {
+		group: "Agent Instructions",
+		order: 3,
+		tasks
+	};
+}
+//#endregion
+//#region src/rules/agent-integration.ts
+var agent_integration_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$4 });
+function evaluate$4(repo) {
+	const tasks = [];
+	if (repo.pathExists(".claude/settings.json")) {
+		if (!repo.fileContains(".claude/settings.json", "inject-tree-context")) tasks.push("Add SessionStart hook to `.claude/settings.json` (see `.context-tree/examples/claude-code/`)");
+	} else if (!repo.anyAgentConfig()) tasks.push("No agent configuration detected. Configure your agent to load tree context at session start. See `.context-tree/examples/` for supported agents. You can skip this and set it up later.");
+	return {
+		group: "Agent Integration",
+		order: 5,
+		tasks
+	};
+}
+//#endregion
+//#region src/rules/ci-validation.ts
+var ci_validation_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$3 });
+function evaluate$3(repo) {
+	const tasks = [];
+	let hasValidation = false;
+	const workflowsDir = join(repo.root, ".github", "workflows");
+	try {
+		if (statSync(workflowsDir).isDirectory()) for (const name of readdirSync(workflowsDir)) {
+			if (!name.endsWith(".yml") && !name.endsWith(".yaml")) continue;
+			const fullPath = join(workflowsDir, name);
+			try {
+				if (!statSync(fullPath).isFile()) continue;
+				const content = readFileSync(fullPath, "utf-8");
+				if (content.includes("validate_nodes") || content.includes("validate_members")) {
+					hasValidation = true;
+					break;
+				}
+			} catch {
+				continue;
+			}
+		}
+	} catch {}
+	if (!hasValidation) tasks.push("No validation workflow found — copy `.context-tree/workflows/validate.yml` to `.github/workflows/validate.yml`");
+	return {
+		group: "CI / Validation",
+		order: 6,
+		tasks
+	};
+}
+//#endregion
+//#region src/rules/framework.ts
+var framework_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$2 });
+const SEED_TREE_URL$1 = "https://github.com/agent-team-foundation/seed-tree";
+function evaluate$2(repo) {
+	const tasks = [];
+	if (!repo.hasFramework()) tasks.push(`\`.context-tree/\` not found — run \`context-tree init\` to clone the framework from ${SEED_TREE_URL$1}`);
+	return {
+		group: "Framework",
+		order: 1,
+		tasks
+	};
+}
+//#endregion
+//#region src/rules/members.ts
+var members_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$1 });
+function evaluate$1(repo) {
+	const tasks = [];
+	if (!repo.pathExists("members")) tasks.push("`members/` directory is missing — create it with a NODE.md");
+	else if (!repo.pathExists("members/NODE.md")) tasks.push("`members/NODE.md` is missing — create it from the template");
+	if (repo.hasMembers() && repo.memberCount() === 0) tasks.push("Add at least one member node for a team member or agent under `members/`");
+	else if (!repo.hasMembers()) tasks.push("Add at least one member node for a team member or agent under `members/`");
+	return {
+		group: "Members",
+		order: 4,
+		tasks
+	};
+}
+//#endregion
+//#region src/rules/root-node.ts
+var root_node_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate });
+function evaluate(repo) {
+	const tasks = [];
+	if (!repo.pathExists("NODE.md")) tasks.push("NODE.md is missing — create from `.context-tree/templates/root-node.md.template`, fill in your project's domains");
+	else {
+		const fm = repo.frontmatter("NODE.md");
+		if (fm === null) tasks.push("NODE.md exists but has no frontmatter — add frontmatter with title and owners fields");
+		else {
+			if (!fm.title || fm.title.startsWith("<")) tasks.push("NODE.md has a placeholder title — replace with your organization name");
+			if (!fm.owners || fm.owners.length === 0 || fm.owners.length === 1 && fm.owners[0].startsWith("<")) tasks.push("NODE.md has placeholder owners — set owners to your GitHub username(s)");
+		}
+		if (repo.hasPlaceholderNode()) tasks.push("NODE.md has placeholder content — fill in your project's domains and description");
+	}
+	return {
+		group: "Root Node",
+		order: 2,
+		tasks
+	};
+}
+//#endregion
+//#region src/rules/index.ts
+const ALL_RULES = [
+	framework_exports,
+	root_node_exports,
+	agent_instructions_exports,
+	members_exports,
+	agent_integration_exports,
+	ci_validation_exports
+];
+function evaluateAll(repo) {
+	const results = [];
+	for (const rule of ALL_RULES) {
+		const result = rule.evaluate(repo);
+		if (result.tasks.length > 0) results.push(result);
+	}
+	return results.sort((a, b) => a.order - b.order);
+}
+//#endregion
+//#region src/init.ts
+const SEED_TREE_URL = "https://github.com/agent-team-foundation/seed-tree";
+const FRAMEWORK_DIR = ".context-tree";
+const TEMPLATE_MAP = [
+	["root-node.md.template", "NODE.md"],
+	["agent.md.template", "AGENT.md"],
+	["members-domain.md.template", "members/NODE.md"]
+];
+function cloneSeedTree() {
+	const tmp = mkdtempSync(join(tmpdir(), "context-tree-"));
+	console.log(`Cloning seed-tree from ${SEED_TREE_URL}...`);
+	try {
+		execFileSync("git", [
+			"clone",
+			"--depth",
+			"1",
+			SEED_TREE_URL,
+			tmp
+		], {
+			encoding: "utf-8",
+			stdio: "pipe"
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "unknown error";
+		console.error(`Failed to clone seed-tree: ${message}`);
+		rmSync(tmp, {
+			recursive: true,
+			force: true
+		});
+		process.exit(1);
+	}
+	return tmp;
+}
+function copyFramework(source, target) {
+	const src = join(source, FRAMEWORK_DIR);
+	const dst = join(target, FRAMEWORK_DIR);
+	if (existsSync(dst)) rmSync(dst, {
+		recursive: true,
+		force: true
+	});
+	cpSync(src, dst, { recursive: true });
+	console.log(`  Copied ${FRAMEWORK_DIR}/`);
+}
+function renderTemplates(frameworkDir, target) {
+	const templatesDir = join(frameworkDir, "templates");
+	for (const [templateName, targetPath] of TEMPLATE_MAP) {
+		const src = join(templatesDir, templateName);
+		const dst = join(target, targetPath);
+		if (existsSync(dst)) console.log(`  Skipped ${targetPath} (already exists)`);
+		else if (existsSync(src)) {
+			mkdirSync(dirname(dst), { recursive: true });
+			copyFileSync(src, dst);
+			console.log(`  Created ${targetPath}`);
+		}
+	}
+}
+function addUpstreamRemote(target) {
+	try {
+		if (!execFileSync("git", ["remote"], {
+			cwd: target,
+			encoding: "utf-8"
+		}).split(/\s+/).includes("context-tree-upstream")) {
+			execFileSync("git", [
+				"remote",
+				"add",
+				"context-tree-upstream",
+				SEED_TREE_URL
+			], {
+				cwd: target,
+				encoding: "utf-8",
+				stdio: "pipe"
+			});
+			console.log(`  Added git remote 'context-tree-upstream' -> ${SEED_TREE_URL}`);
+		}
+	} catch {}
+}
+function formatTaskList(groups) {
+	const lines = ["# Context Tree Init\n"];
+	for (const group of groups) {
+		lines.push(`## ${group.group}`);
+		for (const task of group.tasks) lines.push(`- [ ] ${task}`);
+		lines.push("");
+	}
+	lines.push("## Verification");
+	lines.push("After completing the tasks above, run `context-tree verify` to confirm:");
+	lines.push("- [ ] `.context-tree/VERSION` exists");
+	lines.push("- [ ] Root NODE.md has valid frontmatter (title, owners)");
+	lines.push("- [ ] AGENT.md exists with framework markers");
+	lines.push("- [ ] `context-tree verify` passes with no errors");
+	lines.push("- [ ] At least one member node exists");
+	lines.push("");
+	lines.push("---");
+	lines.push("");
+	lines.push("**Important:** As you complete each task, check it off in `.context-tree/progress.md` by changing `- [ ]` to `- [x]`. Run `context-tree verify` when done — it will fail if any items remain unchecked.");
+	lines.push("");
+	return lines.join("\n");
+}
+function writeProgress(repo, content) {
+	const progressPath = join(repo.root, ".context-tree", "progress.md");
+	mkdirSync(dirname(progressPath), { recursive: true });
+	writeFileSync(progressPath, content);
+}
+function runInit(repo) {
+	const r = repo ?? new Repo();
+	if (!r.isGitRepo()) {
+		console.error("Error: not a git repository. Initialize one first:\n  git init");
+		return 1;
+	}
+	if (!r.hasFramework()) {
+		const seed = cloneSeedTree();
+		try {
+			console.log("Copying framework and scaffolding...");
+			copyFramework(seed, r.root);
+			renderTemplates(join(r.root, FRAMEWORK_DIR), r.root);
+			addUpstreamRemote(r.root);
+		} finally {
+			rmSync(seed, {
+				recursive: true,
+				force: true
+			});
+		}
+		console.log();
+	}
+	const groups = evaluateAll(r);
+	if (groups.length === 0) {
+		console.log("All checks passed. Your context tree is set up.");
+		return 0;
+	}
+	const output = formatTaskList(groups);
+	console.log(output);
+	writeProgress(r, output);
+	console.log("Progress file written to .context-tree/progress.md");
+	return 0;
+}
+//#endregion
+export { runInit };

package/dist/repo-BByc3VvM.js

@@ -0,0 +1,111 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+//#region src/repo.ts
+const FRONTMATTER_RE = /^---\s*\n(.*?)\n---/s;
+const OWNERS_RE = /^owners:\s*\[([^\]]*)\]/m;
+const TITLE_RE = /^title:\s*['"]?(.+?)['"]?\s*$/m;
+const FRAMEWORK_END_MARKER = "<!-- END CONTEXT-TREE FRAMEWORK -->";
+var Repo = class {
+	root;
+	constructor(root) {
+		this.root = resolve(root ?? process.cwd());
+	}
+	pathExists(relPath) {
+		return existsSync(join(this.root, relPath));
+	}
+	fileContains(relPath, text) {
+		const fullPath = join(this.root, relPath);
+		try {
+			if (!statSync(fullPath).isFile()) return false;
+			return readFileSync(fullPath, "utf-8").includes(text);
+		} catch {
+			return false;
+		}
+	}
+	readFile(relPath) {
+		try {
+			return readFileSync(join(this.root, relPath), "utf-8");
+		} catch {
+			return null;
+		}
+	}
+	frontmatter(relPath) {
+		const text = this.readFile(relPath);
+		if (text === null) return null;
+		const m = text.match(FRONTMATTER_RE);
+		if (!m) return null;
+		const fm = m[1];
+		const result = {};
+		const titleM = fm.match(TITLE_RE);
+		if (titleM) result.title = titleM[1].trim();
+		const ownersM = fm.match(OWNERS_RE);
+		if (ownersM) {
+			const raw = ownersM[1].trim();
+			result.owners = raw ? raw.split(",").map((o) => o.trim()).filter(Boolean) : [];
+		}
+		return result.title !== void 0 || result.owners !== void 0 ? result : null;
+	}
+	anyAgentConfig() {
+		return [".claude/settings.json", ".codex/config.json"].some((c) => this.pathExists(c));
+	}
+	isGitRepo() {
+		try {
+			return statSync(join(this.root, ".git")).isDirectory();
+		} catch {
+			return false;
+		}
+	}
+	hasFramework() {
+		return this.pathExists(".context-tree/VERSION");
+	}
+	readVersion() {
+		const text = this.readFile(".context-tree/VERSION");
+		return text ? text.trim() : null;
+	}
+	hasAgentMdMarkers() {
+		const text = this.readFile("AGENT.md");
+		if (text === null) return false;
+		return text.includes("<!-- BEGIN CONTEXT-TREE FRAMEWORK") && text.includes("<!-- END CONTEXT-TREE FRAMEWORK -->");
+	}
+	hasMembers() {
+		const membersDir = join(this.root, "members");
+		try {
+			if (!statSync(membersDir).isDirectory()) return false;
+		} catch {
+			return false;
+		}
+		return existsSync(join(membersDir, "NODE.md"));
+	}
+	memberCount() {
+		const membersDir = join(this.root, "members");
+		try {
+			if (!statSync(membersDir).isDirectory()) return 0;
+		} catch {
+			return 0;
+		}
+		let count = 0;
+		for (const entry of readdirSync(membersDir)) {
+			const childPath = join(membersDir, entry);
+			try {
+				if (statSync(childPath).isDirectory() && existsSync(join(childPath, "NODE.md"))) count++;
+			} catch {}
+		}
+		return count;
+	}
+	hasPlaceholderNode() {
+		return this.fileContains("NODE.md", "<!-- PLACEHOLDER");
+	}
+	hasUpstreamRemote() {
+		try {
+			return execFileSync("git", ["remote"], {
+				cwd: this.root,
+				encoding: "utf-8"
+			}).split(/\s+/).includes("context-tree-upstream");
+		} catch {
+			return false;
+		}
+	}
+};
+//#endregion
+export { Repo as n, FRAMEWORK_END_MARKER as t };

package/dist/upgrade-Chr7z0CY.js

@@ -0,0 +1,82 @@
+import { n as Repo } from "./repo-BByc3VvM.js";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/upgrade.ts
+const SEED_TREE_URL = "https://github.com/agent-team-foundation/seed-tree";
+function getUpstreamVersion(repo) {
+	try {
+		execFileSync("git", [
+			"fetch",
+			"context-tree-upstream",
+			"--depth",
+			"1"
+		], {
+			cwd: repo.root,
+			encoding: "utf-8",
+			stdio: "pipe"
+		});
+	} catch {
+		return null;
+	}
+	try {
+		return execFileSync("git", ["show", "context-tree-upstream/main:.context-tree/VERSION"], {
+			cwd: repo.root,
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+function writeProgress(repo, content) {
+	const progressPath = join(repo.root, ".context-tree", "progress.md");
+	mkdirSync(dirname(progressPath), { recursive: true });
+	writeFileSync(progressPath, content);
+}
+function runUpgrade() {
+	const repo = new Repo();
+	if (!repo.hasFramework()) {
+		console.error("Error: no .context-tree/ found. Run `context-tree init` first.");
+		return 1;
+	}
+	const localVersion = repo.readVersion() ?? "unknown";
+	console.log(`Local framework version: ${localVersion}\n`);
+	if (!repo.hasUpstreamRemote()) {
+		const output = [
+			"# Context Tree Upgrade\n",
+			"## Setup",
+			`- [ ] Add upstream remote: \`git remote add context-tree-upstream ${SEED_TREE_URL}\``,
+			"- [ ] Then run `context-tree upgrade` again to check for updates"
+		].join("\n");
+		console.log(output);
+		writeProgress(repo, output + "\n");
+		console.log("\nProgress file written to .context-tree/progress.md");
+		return 0;
+	}
+	const upstreamVersion = getUpstreamVersion(repo);
+	if (upstreamVersion === null) {
+		console.log("Could not fetch upstream version. Check your network and try again.");
+		return 1;
+	}
+	if (upstreamVersion === localVersion) {
+		console.log(`Already up to date (v${localVersion}).`);
+		return 0;
+	}
+	const lines = [
+		`# Context Tree Upgrade — v${localVersion} -> v${upstreamVersion}\n`,
+		"## Framework",
+		"- [ ] Pull latest from upstream: `git fetch context-tree-upstream && git merge context-tree-upstream/main`",
+		"- [ ] Resolve any conflicts in `.context-tree/` (framework files should generally take upstream version)",
+		""
+	];
+	if (repo.hasAgentMdMarkers()) lines.push("## Agent Instructions", "- [ ] Check if AGENT.md framework section needs updating — compare content between markers to the new template", "");
+	lines.push("## Verification", `- [ ] \`.context-tree/VERSION\` reads \`${upstreamVersion}\``, "- [ ] `context-tree verify` passes", "- [ ] AGENT.md framework section matches upstream", "", "---", "", "**Important:** As you complete each task, check it off in `.context-tree/progress.md` by changing `- [ ]` to `- [x]`. Run `context-tree verify` when done — it will fail if any items remain unchecked.", "");
+	const output = lines.join("\n");
+	console.log(output);
+	writeProgress(repo, output);
+	console.log("Progress file written to .context-tree/progress.md");
+	return 0;
+}
+//#endregion
+export { runUpgrade };

package/dist/verify-DIz6qmBX.js

@@ -0,0 +1,392 @@
+import { n as Repo } from "./repo-BByc3VvM.js";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+//#region src/validators/nodes.ts
+const FRONTMATTER_RE = /^---\s*\n(.*?)\n---/s;
+const OWNERS_RE = /^owners:\s*\[([^\]]*)\]/m;
+const SOFT_LINKS_INLINE_RE = /^soft_links:\s*\[([^\]]*)\]/m;
+const SOFT_LINKS_BLOCK_RE = /^soft_links:\s*\n((?:\s+-\s+.+\n?)+)/m;
+const TITLE_RE = /^title:\s*['"]?(.+?)['"]?\s*$/m;
+const GITHUB_USER_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,37}[a-zA-Z0-9])?$/;
+const SKIP = new Set(["node_modules", "__pycache__"]);
+const SKIP_FILES = new Set(["AGENT.md", "CLAUDE.md"]);
+const MIN_BODY_LENGTH = 20;
+var Findings = class {
+	errors = [];
+	warnings = [];
+	infos = [];
+	error(msg) {
+		this.errors.push(msg);
+	}
+	warning(msg) {
+		this.warnings.push(msg);
+	}
+	info(msg) {
+		this.infos.push(msg);
+	}
+	hasErrors() {
+		return this.errors.length > 0;
+	}
+	printReport(totalFiles) {
+		const all = [
+			...this.errors.map((e) => ["error", e]),
+			...this.warnings.map((w) => ["warning", w]),
+			...this.infos.map((i) => ["info", i])
+		];
+		if (all.length > 0) {
+			const counts = [];
+			if (this.errors.length) counts.push(`${this.errors.length} error(s)`);
+			if (this.warnings.length) counts.push(`${this.warnings.length} warning(s)`);
+			if (this.infos.length) counts.push(`${this.infos.length} info(s)`);
+			console.log(`Found ${counts.join(", ")}:\n`);
+			const icons = {
+				error: "✗",
+				warning: "⚠",
+				info: "ℹ"
+			};
+			for (const [severity, msg] of all) console.log(`  ${icons[severity]} [${severity}] ${msg}`);
+		} else console.log(`All ${totalFiles} node(s) passed validation.`);
+	}
+};
+let treeRoot = "";
+const textCache = /* @__PURE__ */ new Map();
+function setTreeRoot(root) {
+	treeRoot = root;
+	textCache.clear();
+}
+function rel(path) {
+	return relative(treeRoot, path);
+}
+function shouldSkip(path) {
+	return relative(treeRoot, path).split("/").some((part) => SKIP.has(part) || part.startsWith("."));
+}
+function readText(path) {
+	if (!textCache.has(path)) try {
+		textCache.set(path, readFileSync(path, "utf-8"));
+	} catch {
+		textCache.set(path, null);
+	}
+	return textCache.get(path);
+}
+function parseFrontmatter(path) {
+	const text = readText(path);
+	if (text === null) return null;
+	const m = text.match(FRONTMATTER_RE);
+	return m ? m[1] : null;
+}
+function parseBody(path) {
+	const text = readText(path);
+	if (text === null) return null;
+	const m = text.match(FRONTMATTER_RE);
+	if (m) return text.slice(m[0].length);
+	return text;
+}
+function parseSoftLinks(fm) {
+	let m = fm.match(SOFT_LINKS_INLINE_RE);
+	if (m) {
+		const raw = m[1].trim();
+		if (!raw) return [];
+		return raw.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+	}
+	m = fm.match(SOFT_LINKS_BLOCK_RE);
+	if (m) return m[1].trim().split("\n").map((line) => line.trim().replace(/^-\s*/, "").trim().replace(/^['"]|['"]$/g, ""));
+	return null;
+}
+function resolveSoftLink(link) {
+	const clean = link.replace(/^\/+/, "");
+	const target = join(treeRoot, clean);
+	try {
+		if (statSync(target).isFile() && target.endsWith(".md")) return true;
+	} catch {}
+	try {
+		if (statSync(target).isDirectory() && existsSync(join(target, "NODE.md"))) return true;
+	} catch {}
+	return false;
+}
+function normalizeSoftLink(link) {
+	const clean = link.replace(/^\/+/, "");
+	const target = join(treeRoot, clean);
+	try {
+		if (statSync(target).isDirectory()) return join(target, "NODE.md");
+	} catch {}
+	return target;
+}
+function collectMdFiles() {
+	const files = [];
+	function walk(dir) {
+		let entries;
+		try {
+			entries = readdirSync(dir).sort();
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(dir, entry);
+			if (shouldSkip(full)) continue;
+			try {
+				const stat = statSync(full);
+				if (stat.isDirectory()) walk(full);
+				else if (stat.isFile() && entry.endsWith(".md") && !SKIP_FILES.has(entry)) files.push(full);
+			} catch {}
+		}
+	}
+	walk(treeRoot);
+	return files;
+}
+function validateOwners(fm, path, findings) {
+	const m = fm.match(OWNERS_RE);
+	if (!m) {
+		findings.error(`${rel(path)}: missing 'owners' field in frontmatter`);
+		return;
+	}
+	const raw = m[1].trim();
+	if (!raw) return;
+	const owners = raw.split(",").map((o) => o.trim()).filter(Boolean);
+	if (owners.length === 0) {
+		findings.error(`${rel(path)}: owners list contains only whitespace entries`);
+		return;
+	}
+	if (owners.length === 1 && owners[0] === "*") return;
+	for (const owner of owners) if (owner === "*") findings.error(`${rel(path)}: wildcard '*' must be the sole entry, not mixed with usernames`);
+	else if (!GITHUB_USER_RE.test(owner)) findings.error(`${rel(path)}: invalid owner '${owner}'`);
+}
+function validateSoftLinks(fm, path, findings) {
+	const links = parseSoftLinks(fm);
+	if (links === null) return;
+	for (const link of links) if (!link) findings.error(`${rel(path)}: empty soft_link entry`);
+	else if (!resolveSoftLink(link)) findings.error(`${rel(path)}: soft_link '${link}' does not resolve to an existing node`);
+}
+function validateFolders(findings) {
+	function walk(dir) {
+		let entries;
+		try {
+			entries = readdirSync(dir).sort();
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(dir, entry);
+			if (shouldSkip(full)) continue;
+			try {
+				if (!statSync(full).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+			if (!existsSync(join(full, "NODE.md"))) findings.error(`${rel(full)}/: missing NODE.md`);
+			walk(full);
+		}
+	}
+	walk(treeRoot);
+}
+function validateDirectoryListing(findings) {
+	function walk(dir) {
+		let entries;
+		try {
+			entries = readdirSync(dir).sort();
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(dir, entry);
+			if (shouldSkip(full)) continue;
+			try {
+				if (!statSync(full).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+			const nodeMd = join(full, "NODE.md");
+			if (!existsSync(nodeMd)) {
+				walk(full);
+				continue;
+			}
+			const body = parseBody(nodeMd);
+			if (body !== null) {
+				const actualLeaves = /* @__PURE__ */ new Set();
+				for (const f of readdirSync(full).sort()) {
+					const fp = join(full, f);
+					try {
+						if (statSync(fp).isFile() && f.endsWith(".md") && f !== "NODE.md") actualLeaves.add(f);
+					} catch {}
+				}
+				const referenced = /* @__PURE__ */ new Set();
+				let linkMatch;
+				const linkRe = /\[.*?\]\(([^)]+\.md)\)/g;
+				while ((linkMatch = linkRe.exec(body)) !== null) {
+					const ref = linkMatch[1];
+					if (ref.startsWith("http") || ref.startsWith("/")) continue;
+					if (!ref.includes("/")) referenced.add(ref);
+				}
+				for (const orphan of [...actualLeaves].filter((f) => !referenced.has(f)).sort()) findings.warning(`${rel(nodeMd)}: leaf file '${orphan}' exists but is not mentioned in NODE.md`);
+				for (const ref of [...referenced].filter((f) => !actualLeaves.has(f)).sort()) if (!existsSync(join(full, ref))) findings.warning(`${rel(nodeMd)}: references '${ref}' but the file does not exist`);
+			}
+			walk(full);
+		}
+	}
+	walk(treeRoot);
+}
+function validateRootDomainSync(findings) {
+	const body = parseBody(join(treeRoot, "NODE.md"));
+	if (body === null) return;
+	const bodyNoComments = body.replace(/<!--.*?-->/gs, "");
+	const listedDomains = /* @__PURE__ */ new Set();
+	let dm;
+	const domainRe = /\[(\w[\w-]*)\/?\]\((\w[\w-]*)\/NODE\.md\)/g;
+	while ((dm = domainRe.exec(bodyNoComments)) !== null) listedDomains.add(dm[2]);
+	const actualDomains = /* @__PURE__ */ new Set();
+	for (const child of readdirSync(treeRoot).sort()) {
+		const full = join(treeRoot, child);
+		try {
+			if (!statSync(full).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		if (child.startsWith(".") || SKIP.has(child)) continue;
+		if (existsSync(join(full, "NODE.md"))) actualDomains.add(child);
+	}
+	for (const missing of [...actualDomains].filter((d) => !listedDomains.has(d)).sort()) findings.error(`NODE.md: domain directory '${missing}/' exists but is not listed in root NODE.md`);
+	for (const extra of [...listedDomains].filter((d) => !actualDomains.has(d)).sort()) findings.error(`NODE.md: lists domain '${extra}/' but the directory does not exist or has no NODE.md`);
+}
+function validateSoftLinkReciprocity(files, findings) {
+	const allLinks = [];
+	for (const path of files) {
+		const fm = parseFrontmatter(path);
+		if (fm === null) continue;
+		const links = parseSoftLinks(fm);
+		if (!links) continue;
+		for (const link of links) {
+			if (!link) continue;
+			const target = normalizeSoftLink(link);
+			allLinks.push([path, target]);
+		}
+	}
+	for (const [source, target] of allLinks) {
+		if (!existsSync(target)) continue;
+		let hasBackLink = false;
+		const targetFm = parseFrontmatter(target);
+		if (targetFm) {
+			const targetLinks = parseSoftLinks(targetFm);
+			if (targetLinks) for (const tl of targetLinks) {
+				if (!tl) continue;
+				const resolved = normalizeSoftLink(tl);
+				if (resolved === source || resolved === join(source, "..", "NODE.md")) {
+					hasBackLink = true;
+					break;
+				}
+			}
+		}
+		if (!hasBackLink) {
+			const targetBody = parseBody(target);
+			if (targetBody) {
+				const sourceRel = rel(source);
+				const linkRe = /\[.*?\]\(([^)]+\.md)\)/g;
+				let lm;
+				while ((lm = linkRe.exec(targetBody)) !== null) {
+					const ref = lm[1];
+					if (ref.startsWith("http") || ref.startsWith("/")) continue;
+					if (sourceRel.endsWith(ref) || ref === sourceRel) {
+						hasBackLink = true;
+						break;
+					}
+				}
+			}
+		}
+		if (!hasBackLink) findings.info(`${rel(source)}: soft_link to '${rel(target)}' is one-way (target has no reference back)`);
+	}
+}
+function validateEmptyNodes(files, findings) {
+	for (const path of files) {
+		const text = readText(path);
+		if (text === null) continue;
+		const m = text.match(FRONTMATTER_RE);
+		if (!m) continue;
+		if (text.slice(m[0].length).replace(/\s+/g, "").length < MIN_BODY_LENGTH) findings.warning(`${rel(path)}: node has little or no body content`);
+	}
+}
+function validateTitleMismatch(files, findings) {
+	for (const path of files) {
+		const text = readText(path);
+		if (text === null) continue;
+		const fmMatch = text.match(FRONTMATTER_RE);
+		if (!fmMatch) continue;
+		const titleMatch = fmMatch[1].match(TITLE_RE);
+		if (!titleMatch) continue;
+		const fmTitle = titleMatch[1].trim();
+		const headingMatch = text.slice(fmMatch[0].length).match(/^#\s+(.+)$/m);
+		if (!headingMatch) continue;
+		const bodyHeading = headingMatch[1].trim();
+		if (fmTitle !== bodyHeading) findings.warning(`${rel(path)}: frontmatter title '${fmTitle}' differs from first heading '${bodyHeading}'`);
+	}
+}
+function runValidateNodes(root) {
+	setTreeRoot(root);
+	const files = collectMdFiles();
+	const findings = new Findings();
+	validateFolders(findings);
+	for (const path of files) {
+		const fm = parseFrontmatter(path);
+		if (fm === null) {
+			findings.error(`${rel(path)}: no frontmatter found`);
+			continue;
+		}
+		validateOwners(fm, path, findings);
+		validateSoftLinks(fm, path, findings);
+	}
+	validateDirectoryListing(findings);
+	validateRootDomainSync(findings);
+	validateSoftLinkReciprocity(files, findings);
+	validateEmptyNodes(files, findings);
+	validateTitleMismatch(files, findings);
+	findings.printReport(files.length);
+	return {
+		exitCode: findings.hasErrors() ? 1 : 0,
+		findings
+	};
+}
+//#endregion
+//#region src/verify.ts
+const UNCHECKED_RE = /^- \[ \] (.+)$/gm;
+function check(label, passed) {
+	console.log(`  ${passed ? "✓" : "✗"} [${passed ? "PASS" : "FAIL"}] ${label}`);
+	return passed;
+}
+function checkProgress(repo) {
+	const text = repo.readFile(".context-tree/progress.md");
+	if (text === null) return [];
+	const matches = [];
+	let m;
+	UNCHECKED_RE.lastIndex = 0;
+	while ((m = UNCHECKED_RE.exec(text)) !== null) matches.push(m[1]);
+	return matches;
+}
+function defaultNodeValidator(root) {
+	const { exitCode } = runValidateNodes(root);
+	return { exitCode };
+}
+function runVerify(repo, nodeValidator) {
+	const r = repo ?? new Repo();
+	const validate = nodeValidator ?? defaultNodeValidator;
+	let allPassed = true;
+	console.log("Context Tree Verification\n");
+	const unchecked = checkProgress(r);
+	if (unchecked.length > 0) {
+		console.log("  Unchecked items in .context-tree/progress.md:\n");
+		for (const item of unchecked) console.log(`    - [ ] ${item}`);
+		console.log();
+		console.log("  Verify each step above and check it off in progress.md before running verify again.\n");
+		allPassed = false;
+	}
+	console.log("  Checks:\n");
+	allPassed = check(".context-tree/VERSION exists", r.hasFramework()) && allPassed;
+	const fm = r.frontmatter("NODE.md");
+	allPassed = check("Root NODE.md has valid frontmatter (title, owners)", fm !== null && fm.title !== void 0 && fm.owners !== void 0) && allPassed;
+	allPassed = check("AGENT.md exists with framework markers", r.hasAgentMdMarkers()) && allPassed;
+	const { exitCode } = validate(r.root);
+	allPassed = check("Node validation passes", exitCode === 0) && allPassed;
+	allPassed = check("At least one member node exists under members/", r.memberCount() > 0) && allPassed;
+	console.log();
+	if (allPassed) console.log("All checks passed.");
+	else console.log("Some checks failed. See above for details.");
+	return allPassed ? 0 : 1;
+}
+//#endregion
+export { runVerify };

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "first-tree",
+  "version": "0.0.1",
+  "description": "CLI tools for Context Tree — the living source of truth for your organization.",
+  "type": "module",
+  "bin": {
+    "context-tree": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown src/cli.ts --format esm --out-dir dist",
+    "prepublishOnly": "pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsdown": "^0.12.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  }
+}