first-tree 0.0.3 → 0.0.4

package/skills/first-tree/tests/init.test.ts

@@ -1,17 +1,27 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { formatTaskList, writeProgress, runInit } from "#skill/engine/init.js";
+import {
+  formatTaskList,
+  parseInitArgs,
+  writeProgress,
+  runInit,
+} from "#skill/engine/init.js";
 import { Repo } from "#skill/engine/repo.js";
 import {
+  AGENT_INSTRUCTIONS_FILE,
   FRAMEWORK_VERSION,
   INSTALLED_PROGRESS,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
   LEGACY_PROGRESS,
 } from "#skill/engine/runtime/asset-loader.js";
 import {
+  makeGitRepo,
   useTmpDir,
+  makeAgentsMd,
   makeFramework,
   makeLegacyFramework,
+  makeSourceRepo,
   makeSourceSkill,
 } from "./helpers.js";
 
@@ -110,6 +120,10 @@ describe("writeProgress", () => {
 
 // --- runInit — guard logic (no network) ---
 
+const fakeGitInitializer = (root: string): void => {
+  makeGitRepo(root);
+};
+
 describe("runInit", () => {
   it("errors when not a git repo", () => {
     const tmp = useTmpDir();
@@ -121,10 +135,13 @@ describe("runInit", () => {
   it("installs the bundled skill and scaffolding when framework is missing", () => {
     const repoDir = useTmpDir();
     const sourceDir = useTmpDir();
-    mkdirSync(join(repoDir.path, ".git"));
+    makeGitRepo(repoDir.path);
     makeSourceSkill(sourceDir.path, "0.2.0");
 
-    const ret = runInit(new Repo(repoDir.path), { sourceRoot: sourceDir.path });
+    const ret = runInit(new Repo(repoDir.path), {
+      sourceRoot: sourceDir.path,
+      gitInitializer: fakeGitInitializer,
+    });
 
     expect(ret).toBe(0);
     expect(
@@ -132,15 +149,32 @@ describe("runInit", () => {
     ).toBe(true);
     expect(readFileSync(join(repoDir.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.2.0");
     expect(existsSync(join(repoDir.path, "NODE.md"))).toBe(true);
-    expect(existsSync(join(repoDir.path, "AGENT.md"))).toBe(true);
+    expect(existsSync(join(repoDir.path, AGENT_INSTRUCTIONS_FILE))).toBe(true);
     expect(existsSync(join(repoDir.path, "members", "NODE.md"))).toBe(true);
     expect(existsSync(join(repoDir.path, INSTALLED_PROGRESS))).toBe(true);
   });
 
+  it("does not scaffold AGENTS.md when legacy AGENT.md already exists", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    mkdirSync(join(repoDir.path, ".git"));
+    makeAgentsMd(repoDir.path, { legacyName: true, markers: true, userContent: true });
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(repoDir.path), { sourceRoot: sourceDir.path });
+
+    expect(ret).toBe(0);
+    expect(existsSync(join(repoDir.path, LEGACY_AGENT_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(repoDir.path, AGENT_INSTRUCTIONS_FILE))).toBe(false);
+    expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
+      "Rename `AGENT.md` to `AGENTS.md`",
+    );
+  });
+
   it("skips reinstall when framework exists", () => {
     const tmp = useTmpDir();
     const sourceDir = useTmpDir();
-    mkdirSync(join(tmp.path, ".git"));
+    makeGitRepo(tmp.path);
     makeFramework(tmp.path, "0.1.0");
     makeSourceSkill(sourceDir.path, "0.2.0");
 
@@ -150,4 +184,67 @@ describe("runInit", () => {
     expect(ret).toBe(0);
     expect(readFileSync(join(tmp.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.1.0");
   });
+
+  it("creates a sibling tree repo by default when invoked from a source repo", () => {
+    const sourceRepoDir = useTmpDir();
+    const sourceSkillDir = useTmpDir();
+    makeSourceRepo(sourceRepoDir.path);
+    makeSourceSkill(sourceSkillDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(sourceRepoDir.path), {
+      sourceRoot: sourceSkillDir.path,
+      gitInitializer: fakeGitInitializer,
+    });
+
+    const treeRepo = join(
+      dirname(sourceRepoDir.path),
+      `${basename(sourceRepoDir.path)}-context`,
+    );
+
+    expect(ret).toBe(0);
+    expect(existsSync(join(treeRepo, "skills", "first-tree", "SKILL.md"))).toBe(true);
+    expect(existsSync(join(treeRepo, "NODE.md"))).toBe(true);
+    expect(existsSync(join(treeRepo, AGENT_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(treeRepo, "members", "NODE.md"))).toBe(true);
+    expect(existsSync(join(treeRepo, INSTALLED_PROGRESS))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, "NODE.md"))).toBe(false);
+    expect(existsSync(join(sourceRepoDir.path, "members", "NODE.md"))).toBe(false);
+    expect(existsSync(join(sourceRepoDir.path, INSTALLED_PROGRESS))).toBe(false);
+  });
+
+  it("keeps supporting in-place init with --here", () => {
+    const sourceRepoDir = useTmpDir();
+    const sourceSkillDir = useTmpDir();
+    makeSourceRepo(sourceRepoDir.path);
+    makeSourceSkill(sourceSkillDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(sourceRepoDir.path), {
+      here: true,
+      sourceRoot: sourceSkillDir.path,
+      gitInitializer: fakeGitInitializer,
+    });
+
+    expect(ret).toBe(0);
+    expect(existsSync(join(sourceRepoDir.path, "NODE.md"))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, AGENT_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, "members", "NODE.md"))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, INSTALLED_PROGRESS))).toBe(true);
+  });
+});
+
+describe("parseInitArgs", () => {
+  it("parses dedicated repo options", () => {
+    expect(parseInitArgs(["--tree-name", "acme-context"])).toEqual({
+      treeName: "acme-context",
+    });
+    expect(parseInitArgs(["--tree-path", "../acme-context"])).toEqual({
+      treePath: "../acme-context",
+    });
+  });
+
+  it("rejects incompatible init options", () => {
+    expect(parseInitArgs(["--here", "--tree-name", "acme-context"])).toEqual({
+      error: "Cannot combine --here with --tree-name",
+    });
+  });
 });

package/skills/first-tree/tests/repo.test.ts

@@ -3,8 +3,10 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { Repo } from "#skill/engine/repo.js";
 import {
+  AGENT_INSTRUCTIONS_FILE,
   FRAMEWORK_VERSION,
   INSTALLED_PROGRESS,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
   LEGACY_SKILL_PROGRESS,
   LEGACY_SKILL_VERSION,
   LEGACY_PROGRESS,
@@ -13,8 +15,11 @@ import {
 import {
   useTmpDir,
   makeFramework,
+  makeGitRepo,
   makeLegacyFramework,
   makeLegacyNamedFramework,
+  makeSourceRepo,
+  makeSourceSkill,
 } from "./helpers.js";
 
 // --- pathExists ---
@@ -134,7 +139,14 @@ describe("anyAgentConfig", () => {
 describe("isGitRepo", () => {
   it("returns true with .git dir", () => {
     const tmp = useTmpDir();
-    mkdirSync(join(tmp.path, ".git"));
+    makeGitRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.isGitRepo()).toBe(true);
+  });
+
+  it("returns true with .git file", () => {
+    const tmp = useTmpDir();
+    writeFileSync(join(tmp.path, ".git"), "gitdir: /tmp/example\n");
     const repo = new Repo(tmp.path);
     expect(repo.isGitRepo()).toBe(true);
   });
@@ -235,33 +247,56 @@ describe("path preferences", () => {
   });
 });
 
-// --- hasAgentMdMarkers ---
+// --- agent instructions helpers ---
+
+describe("agent instructions helpers", () => {
+  it("prefers AGENTS.md when both filenames exist", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, AGENT_INSTRUCTIONS_FILE),
+      "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nstuff\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
+    );
+    writeFileSync(
+      join(tmp.path, LEGACY_AGENT_INSTRUCTIONS_FILE),
+      "# Legacy instructions\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.agentInstructionsPath()).toBe(AGENT_INSTRUCTIONS_FILE);
+    expect(repo.hasCanonicalAgentInstructionsFile()).toBe(true);
+    expect(repo.hasLegacyAgentInstructionsFile()).toBe(true);
+    expect(repo.hasDuplicateAgentInstructionsFiles()).toBe(true);
+    expect(repo.hasAgentInstructionsMarkers()).toBe(true);
+  });
 
-describe("hasAgentMdMarkers", () => {
-  it("returns true with markers", () => {
+  it("falls back to legacy AGENT.md while migrating", () => {
     const tmp = useTmpDir();
     writeFileSync(
-      join(tmp.path, "AGENT.md"),
+      join(tmp.path, LEGACY_AGENT_INSTRUCTIONS_FILE),
       "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nstuff\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
     );
     const repo = new Repo(tmp.path);
-    expect(repo.hasAgentMdMarkers()).toBe(true);
+    expect(repo.agentInstructionsPath()).toBe(LEGACY_AGENT_INSTRUCTIONS_FILE);
+    expect(repo.hasCanonicalAgentInstructionsFile()).toBe(false);
+    expect(repo.hasLegacyAgentInstructionsFile()).toBe(true);
+    expect(repo.hasDuplicateAgentInstructionsFiles()).toBe(false);
+    expect(repo.hasAgentInstructionsMarkers()).toBe(true);
   });
 
   it("returns false without markers", () => {
     const tmp = useTmpDir();
     writeFileSync(
-      join(tmp.path, "AGENT.md"),
+      join(tmp.path, AGENT_INSTRUCTIONS_FILE),
       "# Agent instructions\nNo markers here.\n",
     );
     const repo = new Repo(tmp.path);
-    expect(repo.hasAgentMdMarkers()).toBe(false);
+    expect(repo.hasAgentInstructionsMarkers()).toBe(false);
   });
 
   it("returns false when file is missing", () => {
     const tmp = useTmpDir();
     const repo = new Repo(tmp.path);
-    expect(repo.hasAgentMdMarkers()).toBe(false);
+    expect(repo.agentInstructionsPath()).toBeNull();
+    expect(repo.hasAgentInstructionsMarkers()).toBe(false);
   });
 });
 
@@ -360,3 +395,46 @@ describe("hasPlaceholderNode", () => {
     expect(repo.hasPlaceholderNode()).toBe(false);
   });
 });
+
+// --- init heuristics ---
+
+describe("init heuristics", () => {
+  it("treats a code repo as a likely source repo", () => {
+    const tmp = useTmpDir();
+    makeSourceRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.isLikelySourceRepo()).toBe(true);
+    expect(repo.isLikelyEmptyRepo()).toBe(false);
+  });
+
+  it("treats a fresh tree repo as empty enough for in-place init", () => {
+    const tmp = useTmpDir();
+    makeGitRepo(tmp.path);
+    writeFileSync(join(tmp.path, "README.md"), "# My Org Context\n");
+    const repo = new Repo(tmp.path);
+    expect(repo.isLikelyEmptyRepo()).toBe(true);
+    expect(repo.isLikelySourceRepo()).toBe(false);
+  });
+
+  it("recognizes a populated tree repo", () => {
+    const tmp = useTmpDir();
+    makeFramework(tmp.path);
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "---\ntitle: My Tree\nowners: [alice]\n---\n# Tree\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.looksLikeTreeRepo()).toBe(true);
+    expect(repo.isLikelySourceRepo()).toBe(false);
+  });
+
+  it("does not mistake the framework source repo for a user tree repo", () => {
+    const tmp = useTmpDir();
+    makeSourceRepo(tmp.path);
+    makeSourceSkill(tmp.path, "0.2.0");
+    writeFileSync(join(tmp.path, "src", "cli.ts"), "export {};\n");
+    const repo = new Repo(tmp.path);
+    expect(repo.looksLikeTreeRepo()).toBe(false);
+    expect(repo.isLikelySourceRepo()).toBe(true);
+  });
+});

package/skills/first-tree/tests/rules.test.ts

@@ -16,7 +16,7 @@ import {
   useTmpDir,
   makeFramework,
   makeNode,
-  makeAgentMd,
+  makeAgentsMd,
   makeMembers,
 } from "./helpers.js";
 
@@ -104,16 +104,35 @@ describe("rootNode rule", () => {
 // --- agent_instructions rule ---
 
 describe("agentInstructions rule", () => {
-  it("reports missing AGENT.md", () => {
+  it("reports missing AGENTS.md", () => {
     const tmp = useTmpDir();
     const repo = new Repo(tmp.path);
     const result = agentInstructions.evaluate(repo);
-    expect(result.tasks.some((t) => t.toLowerCase().includes("missing"))).toBe(true);
+    expect(result.tasks.some((t) => t.includes("AGENTS.md is missing"))).toBe(true);
+  });
+
+  it("reports legacy AGENT.md rename", () => {
+    const tmp = useTmpDir();
+    makeAgentsMd(tmp.path, { legacyName: true, markers: true, userContent: true });
+    const repo = new Repo(tmp.path);
+    const result = agentInstructions.evaluate(repo);
+    expect(result.tasks.some((t) => t.includes("Rename `AGENT.md` to `AGENTS.md`"))).toBe(
+      true,
+    );
+  });
+
+  it("reports duplicate cleanup when both filenames exist", () => {
+    const tmp = useTmpDir();
+    makeAgentsMd(tmp.path, { markers: true, userContent: true });
+    makeAgentsMd(tmp.path, { legacyName: true, markers: true, userContent: true });
+    const repo = new Repo(tmp.path);
+    const result = agentInstructions.evaluate(repo);
+    expect(result.tasks.some((t) => t.includes("delete the legacy file"))).toBe(true);
   });
 
   it("reports no markers", () => {
     const tmp = useTmpDir();
-    makeAgentMd(tmp.path, { markers: false });
+    makeAgentsMd(tmp.path, { markers: false });
     const repo = new Repo(tmp.path);
     const result = agentInstructions.evaluate(repo);
     expect(result.tasks.some((t) => t.toLowerCase().includes("markers"))).toBe(true);
@@ -121,7 +140,7 @@ describe("agentInstructions rule", () => {
 
   it("reports no user content", () => {
     const tmp = useTmpDir();
-    makeAgentMd(tmp.path, { markers: true, userContent: false });
+    makeAgentsMd(tmp.path, { markers: true, userContent: false });
     const repo = new Repo(tmp.path);
     const result = agentInstructions.evaluate(repo);
     expect(result.tasks.some((t) => t.toLowerCase().includes("project-specific"))).toBe(true);
@@ -129,7 +148,7 @@ describe("agentInstructions rule", () => {
 
   it("passes with markers and user content", () => {
     const tmp = useTmpDir();
-    makeAgentMd(tmp.path, { markers: true, userContent: true });
+    makeAgentsMd(tmp.path, { markers: true, userContent: true });
     const repo = new Repo(tmp.path);
     const result = agentInstructions.evaluate(repo);
     expect(result.tasks).toEqual([]);
@@ -365,7 +384,7 @@ describe("evaluateAll", () => {
     const tmp = useTmpDir();
     makeFramework(tmp.path);
     makeNode(tmp.path);
-    makeAgentMd(tmp.path, { markers: true, userContent: true });
+    makeAgentsMd(tmp.path, { markers: true, userContent: true });
     makeMembers(tmp.path, 1);
     mkdirSync(join(tmp.path, ".claude"));
     writeFileSync(

package/skills/first-tree/tests/skill-artifacts.test.ts

@@ -22,6 +22,7 @@ describe("skill artifacts", () => {
     expect(existsSync(join(ROOT, "skills", "first-tree", "references", "onboarding.md"))).toBe(true);
     expect(existsSync(join(ROOT, "skills", "first-tree", "assets", "framework", "manifest.json"))).toBe(true);
     expect(existsSync(join(ROOT, "skills", "first-tree", "engine", "init.ts"))).toBe(true);
+    expect(existsSync(join(ROOT, "AGENTS.md"))).toBe(true);
     expect(existsSync(join(ROOT, "skills", "first-tree", "tests", "init.test.ts"))).toBe(
       true,
     );
@@ -114,6 +115,7 @@ describe("skill artifacts", () => {
     expect(isTrackedInGit(".agents")).toBe(false);
     expect(isTrackedInGit(".claude")).toBe(false);
     expect(isTrackedInGit(".context-tree")).toBe(false);
+    expect(existsSync(join(ROOT, "AGENT.md"))).toBe(false);
     expect(isTrackedInGit("skills/first-tree-cli-framework")).toBe(false);
     expect(isTrackedInGit("docs")).toBe(false);
     expect(isTrackedInGit("tests")).toBe(false);
@@ -200,6 +202,7 @@ describe("skill artifacts", () => {
     expect(read("README.md")).toContain("references/source-map.md");
     expect(read("README.md")).toContain("skills/first-tree/");
     expect(read("README.md")).toContain("bundled canonical");
+    expect(read("README.md")).toContain("dedicated tree repo");
     expect(read("README.md")).toContain("`first-tree` skill");
     expect(read("AGENTS.md")).toContain("references/source-map.md");
     expect(read("AGENTS.md")).toContain("bundled skill path");
@@ -211,6 +214,7 @@ describe("skill artifacts", () => {
     const onboarding = read("skills/first-tree/references/onboarding.md");
     expect(onboarding).toContain("npx first-tree init");
     expect(onboarding).toContain("npm install -g first-tree");
+    expect(onboarding).toContain("context-tree init --here");
     expect(onboarding).toContain("installed CLI command is");
     expect(onboarding).toContain("currently running `first-tree` npm package");
     expect(onboarding).toContain("npx first-tree@latest upgrade");

package/skills/first-tree/tests/thin-cli.test.ts

@@ -1,9 +1,17 @@
-import { readFileSync } from "node:fs";
+import {
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { USAGE, runCli } from "../../../src/cli.ts";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+import { USAGE, isDirectExecution, runCli } from "../../../src/cli.ts";
 
-const ROOT = process.cwd();
+const TEMP_DIRS: string[] = [];
 
 function captureOutput(): { lines: string[]; write: (text: string) => void } {
   const lines: string[] = [];
@@ -15,7 +23,45 @@ function captureOutput(): { lines: string[]; write: (text: string) => void } {
   };
 }
 
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "first-tree-thin-cli-"));
+  TEMP_DIRS.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  while (TEMP_DIRS.length > 0) {
+    const dir = TEMP_DIRS.pop();
+    if (dir) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});
+
 describe("thin CLI shell", () => {
+  it("treats a symlinked npm bin path as direct execution", () => {
+    const dir = makeTempDir();
+    const target = join(dir, "cli.js");
+    const symlinkPath = join(dir, "context-tree");
+
+    writeFileSync(target, "#!/usr/bin/env node\n");
+    symlinkSync(target, symlinkPath);
+
+    expect(isDirectExecution(symlinkPath, pathToFileURL(target).href)).toBe(true);
+  });
+
+  it("does not treat unrelated argv[1] values as direct execution", () => {
+    const dir = makeTempDir();
+    const target = join(dir, "cli.js");
+    const other = join(dir, "other.js");
+
+    writeFileSync(target, "#!/usr/bin/env node\n");
+    writeFileSync(other, "#!/usr/bin/env node\n");
+
+    expect(isDirectExecution(other, pathToFileURL(target).href)).toBe(false);
+    expect(isDirectExecution(undefined, pathToFileURL(target).href)).toBe(false);
+  });
+
   it("prints usage with no args", async () => {
     const output = captureOutput();
 
@@ -27,9 +73,8 @@ describe("thin CLI shell", () => {
 
   it("prints the package version", async () => {
     const output = captureOutput();
-    const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8")) as {
-      version: string;
-    };
+    const pkgPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { version: string };
 
     const code = await runCli(["--version"], output.write);
 

package/skills/first-tree/tests/upgrade.test.ts

@@ -1,14 +1,18 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { Repo } from "#skill/engine/repo.js";
 import { runUpgrade } from "#skill/engine/upgrade.js";
 import {
+  AGENT_INSTRUCTIONS_FILE,
   FRAMEWORK_VERSION,
   INSTALLED_PROGRESS,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
 } from "#skill/engine/runtime/asset-loader.js";
 import {
+  makeAgentsMd,
   makeFramework,
+  makeSourceRepo,
   makeLegacyFramework,
   makeLegacyNamedFramework,
   makeSourceSkill,
@@ -20,10 +24,7 @@ describe("runUpgrade", () => {
     const repoDir = useTmpDir();
     const sourceDir = useTmpDir();
     makeLegacyFramework(repoDir.path, "0.1.0");
-    writeFileSync(
-      join(repoDir.path, "AGENT.md"),
-      "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nstuff\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
-    );
+    makeAgentsMd(repoDir.path, { legacyName: true, markers: true, userContent: true });
     makeSourceSkill(sourceDir.path, "0.2.0");
 
     const result = runUpgrade(new Repo(repoDir.path), {
@@ -36,6 +37,12 @@ describe("runUpgrade", () => {
     expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
       "skills/first-tree/assets/framework/VERSION",
     );
+    expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
+      `Rename \`${LEGACY_AGENT_INSTRUCTIONS_FILE}\` to \`${AGENT_INSTRUCTIONS_FILE}\``,
+    );
+    expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
+      "skills/first-tree/assets/framework/templates/agents.md.template",
+    );
   });
 
   it("returns early when the installed skill already matches the packaged skill", () => {
@@ -86,4 +93,11 @@ describe("runUpgrade", () => {
     expect(readFileSync(join(repoDir.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.3.0");
     expect(existsSync(join(repoDir.path, INSTALLED_PROGRESS))).toBe(false);
   });
+
+  it("gives a dedicated-tree hint when run from a source repo", () => {
+    const repoDir = useTmpDir();
+    makeSourceRepo(repoDir.path);
+    const result = runUpgrade(new Repo(repoDir.path));
+    expect(result).toBe(1);
+  });
 });