first-tree 0.0.3 → 0.0.5

package/skills/first-tree/scripts/check-skill-sync.sh

@@ -70,7 +70,7 @@ require_file "$SOURCE_DIR/assets/framework/manifest.json"
 require_file "$SOURCE_DIR/assets/framework/VERSION"
 require_file "$SOURCE_DIR/assets/framework/prompts/pr-review.md"
 require_file "$SOURCE_DIR/assets/framework/templates/root-node.md.template"
-require_file "$SOURCE_DIR/assets/framework/templates/agent.md.template"
+require_file "$SOURCE_DIR/assets/framework/templates/agents.md.template"
 require_file "$SOURCE_DIR/assets/framework/templates/members-domain.md.template"
 require_file "$SOURCE_DIR/assets/framework/templates/member-node.md.template"
 require_file "$SOURCE_DIR/assets/framework/workflows/validate.yml"

package/skills/first-tree/tests/asset-loader.test.ts

@@ -2,8 +2,11 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import {
+  CLAUDE_INSTALLED_PROGRESS,
   FRAMEWORK_VERSION,
   INSTALLED_PROGRESS,
+  LEGACY_REPO_SKILL_PROGRESS,
+  LEGACY_REPO_SKILL_VERSION,
   LEGACY_SKILL_PROGRESS,
   LEGACY_SKILL_VERSION,
   LEGACY_PROGRESS,
@@ -18,7 +21,7 @@ import { useTmpDir } from "./helpers.js";
 describe("asset-loader", () => {
   it("prefers the installed skill layout when both layouts exist", () => {
     const tmp = useTmpDir();
-    mkdirSync(join(tmp.path, "skills", "first-tree", "assets", "framework"), {
+    mkdirSync(join(tmp.path, ".agents", "skills", "first-tree", "assets", "framework"), {
       recursive: true,
     });
     mkdirSync(join(tmp.path, ".context-tree"), { recursive: true });
@@ -39,6 +42,21 @@ describe("asset-loader", () => {
     expect(detectFrameworkLayout(tmp.path)).toBe("legacy");
   });
 
+  it("detects the previous workspace skill path before older layouts", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree", "assets", "framework"), {
+      recursive: true,
+    });
+    mkdirSync(join(tmp.path, ".context-tree"), { recursive: true });
+    writeFileSync(join(tmp.path, LEGACY_REPO_SKILL_VERSION), "0.2.0\n");
+    writeFileSync(join(tmp.path, LEGACY_VERSION), "0.1.0\n");
+
+    expect(detectFrameworkLayout(tmp.path)).toBe("legacy-repo-skill");
+    expect(
+      resolveFirstExistingPath(tmp.path, frameworkVersionCandidates()),
+    ).toBe(LEGACY_REPO_SKILL_VERSION);
+  });
+
   it("detects the previous installed skill name before the .context-tree layout", () => {
     const tmp = useTmpDir();
     mkdirSync(
@@ -59,12 +77,16 @@ describe("asset-loader", () => {
 
   it("prefers the installed progress file candidate", () => {
     const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, ".agents", "skills", "first-tree"), { recursive: true });
+    mkdirSync(join(tmp.path, ".claude", "skills", "first-tree"), { recursive: true });
     mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
     mkdirSync(join(tmp.path, "skills", "first-tree-cli-framework"), {
       recursive: true,
     });
     mkdirSync(join(tmp.path, ".context-tree"), { recursive: true });
     writeFileSync(join(tmp.path, INSTALLED_PROGRESS), "new");
+    writeFileSync(join(tmp.path, CLAUDE_INSTALLED_PROGRESS), "claude");
+    writeFileSync(join(tmp.path, LEGACY_REPO_SKILL_PROGRESS), "old-repo-skill");
     writeFileSync(join(tmp.path, LEGACY_SKILL_PROGRESS), "old-skill");
     writeFileSync(join(tmp.path, LEGACY_PROGRESS), "old");
 

package/skills/first-tree/tests/helpers.ts

@@ -3,9 +3,15 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { afterEach } from "vitest";
 import {
+  AGENT_INSTRUCTIONS_FILE,
+  AGENT_INSTRUCTIONS_TEMPLATE,
+  CLAUDE_SKILL_ROOT,
   FRAMEWORK_VERSION,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
+  LEGACY_REPO_SKILL_VERSION,
   LEGACY_SKILL_VERSION,
   LEGACY_VERSION,
+  SKILL_ROOT,
 } from "#skill/engine/runtime/asset-loader.js";
 
 interface TmpDir {
@@ -21,10 +27,34 @@ export function useTmpDir(): TmpDir {
 }
 
 export function makeFramework(root: string, version = "0.1.0"): void {
-  mkdirSync(join(root, "skills", "first-tree", "assets", "framework"), {
-    recursive: true,
-  });
+  for (const skillRoot of [SKILL_ROOT, CLAUDE_SKILL_ROOT]) {
+    mkdirSync(join(root, skillRoot, "assets", "framework"), {
+      recursive: true,
+    });
+    writeFileSync(
+      join(root, skillRoot, "SKILL.md"),
+      "---\nname: first-tree\ndescription: installed\n---\n",
+    );
+  }
   writeFileSync(join(root, FRAMEWORK_VERSION), `${version}\n`);
+  writeFileSync(
+    join(root, CLAUDE_SKILL_ROOT, "assets", "framework", "VERSION"),
+    `${version}\n`,
+  );
+}
+
+export function makeGitRepo(root: string): void {
+  mkdirSync(join(root, ".git"), { recursive: true });
+}
+
+export function makeSourceRepo(root: string): void {
+  makeGitRepo(root);
+  mkdirSync(join(root, "src"), { recursive: true });
+  writeFileSync(
+    join(root, "package.json"),
+    JSON.stringify({ name: "example-source-repo" }, null, 2),
+  );
+  writeFileSync(join(root, "src", "index.ts"), "export const ready = true;\n");
 }
 
 export function makeLegacyFramework(root: string, version = "0.1.0"): void {
@@ -33,6 +63,17 @@ export function makeLegacyFramework(root: string, version = "0.1.0"): void {
   writeFileSync(join(root, LEGACY_VERSION), `${version}\n`);
 }
 
+export function makeLegacyRepoFramework(root: string, version = "0.1.0"): void {
+  mkdirSync(join(root, "skills", "first-tree", "assets", "framework"), {
+    recursive: true,
+  });
+  writeFileSync(
+    join(root, "skills", "first-tree", "SKILL.md"),
+    "---\nname: first-tree\ndescription: legacy installed\n---\n",
+  );
+  writeFileSync(join(root, LEGACY_REPO_SKILL_VERSION), `${version}\n`);
+}
+
 export function makeLegacyNamedFramework(
   root: string,
   version = "0.1.0",
@@ -85,7 +126,7 @@ export function makeSourceSkill(root: string, version = "0.2.0"): void {
       "assets",
       "framework",
       "templates",
-      "agent.md.template",
+      AGENT_INSTRUCTIONS_TEMPLATE,
     ),
     "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nframework text\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
   );
@@ -114,12 +155,15 @@ export function makeNode(
   );
 }
 
-export function makeAgentMd(
+export function makeAgentsMd(
   root: string,
-  opts?: { markers?: boolean; userContent?: boolean },
+  opts?: { markers?: boolean; userContent?: boolean; legacyName?: boolean },
 ): void {
   const markers = opts?.markers ?? true;
   const userContent = opts?.userContent ?? false;
+  const fileName = opts?.legacyName
+    ? LEGACY_AGENT_INSTRUCTIONS_FILE
+    : AGENT_INSTRUCTIONS_FILE;
   const parts: string[] = [];
   if (markers) {
     parts.push(
@@ -131,7 +175,7 @@ export function makeAgentMd(
   if (userContent) {
     parts.push("\n# Project-specific\nThis is real user content.\n");
   }
-  writeFileSync(join(root, "AGENT.md"), parts.join("\n"));
+  writeFileSync(join(root, fileName), parts.join("\n"));
 }
 
 export function makeMembers(root: string, count = 1): void {

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";
 
@@ -90,7 +100,7 @@ describe("writeProgress", () => {
 
   it("overwrites existing file", () => {
     const tmp = useTmpDir();
-    mkdirSync(join(tmp.path, "skills", "first-tree"), {
+    mkdirSync(join(tmp.path, ".agents", "skills", "first-tree"), {
       recursive: true,
     });
     writeFileSync(join(tmp.path, INSTALLED_PROGRESS), "old");
@@ -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,26 +135,49 @@ 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(
-      existsSync(join(repoDir.path, "skills", "first-tree", "SKILL.md")),
+      existsSync(join(repoDir.path, ".agents", "skills", "first-tree", "SKILL.md")),
+    ).toBe(true);
+    expect(
+      existsSync(join(repoDir.path, ".claude", "skills", "first-tree", "SKILL.md")),
     ).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 +187,72 @@ 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, ".agents", "skills", "first-tree", "SKILL.md")),
+    ).toBe(true);
+    expect(
+      existsSync(join(treeRepo, ".claude", "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,13 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { Repo } from "#skill/engine/repo.js";
 import {
+  AGENT_INSTRUCTIONS_FILE,
+  CLAUDE_INSTALLED_PROGRESS,
   FRAMEWORK_VERSION,
   INSTALLED_PROGRESS,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
+  LEGACY_REPO_SKILL_PROGRESS,
+  LEGACY_REPO_SKILL_VERSION,
   LEGACY_SKILL_PROGRESS,
   LEGACY_SKILL_VERSION,
   LEGACY_PROGRESS,
@@ -13,8 +18,12 @@ import {
 import {
   useTmpDir,
   makeFramework,
+  makeGitRepo,
   makeLegacyFramework,
+  makeLegacyRepoFramework,
   makeLegacyNamedFramework,
+  makeSourceRepo,
+  makeSourceSkill,
 } from "./helpers.js";
 
 // --- pathExists ---
@@ -134,7 +143,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);
   });
@@ -170,6 +186,13 @@ describe("hasFramework", () => {
     expect(repo.hasFramework()).toBe(true);
   });
 
+  it("returns true with the previous workspace skill path", () => {
+    const tmp = useTmpDir();
+    makeLegacyRepoFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.hasFramework()).toBe(true);
+  });
+
   it("returns false without VERSION file", () => {
     const tmp = useTmpDir();
     const repo = new Repo(tmp.path);
@@ -201,6 +224,13 @@ describe("readVersion", () => {
     expect(repo.readVersion()).toBe("0.2.5");
   });
 
+  it("reads the previous workspace skill version", () => {
+    const tmp = useTmpDir();
+    makeLegacyRepoFramework(tmp.path, "0.2.4");
+    const repo = new Repo(tmp.path);
+    expect(repo.readVersion()).toBe("0.2.4");
+  });
+
   it("returns null when missing", () => {
     const tmp = useTmpDir();
     const repo = new Repo(tmp.path);
@@ -233,35 +263,66 @@ describe("path preferences", () => {
     expect(repo.preferredProgressPath()).toBe(LEGACY_SKILL_PROGRESS);
     expect(repo.frameworkVersionPath()).toBe(LEGACY_SKILL_VERSION);
   });
+
+  it("switches path preferences for repos using the previous workspace skill path", () => {
+    const tmp = useTmpDir();
+    makeLegacyRepoFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.preferredProgressPath()).toBe(LEGACY_REPO_SKILL_PROGRESS);
+    expect(repo.frameworkVersionPath()).toBe(LEGACY_REPO_SKILL_VERSION);
+  });
 });
 
-// --- hasAgentMdMarkers ---
+// --- agent instructions helpers ---
 
-describe("hasAgentMdMarkers", () => {
-  it("returns true with markers", () => {
+describe("agent instructions helpers", () => {
+  it("prefers AGENTS.md when both filenames exist", () => {
     const tmp = useTmpDir();
     writeFileSync(
-      join(tmp.path, "AGENT.md"),
+      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.hasAgentMdMarkers()).toBe(true);
+    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);
+  });
+
+  it("falls back to legacy AGENT.md while migrating", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      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.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 +421,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";
 
@@ -29,7 +29,7 @@ describe("framework rule", () => {
     const result = framework.evaluate(repo);
     expect(result.group).toBe("Framework");
     expect(result.tasks).toHaveLength(1);
-    expect(result.tasks[0]).toContain("skills/first-tree/");
+    expect(result.tasks[0]).toContain(".agents/skills/first-tree/");
   });
 
   it("passes when framework exists", () => {
@@ -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([]);
@@ -214,7 +233,9 @@ describe("ciValidation rule", () => {
     const result = ciValidation.evaluate(repo);
     expect(result.tasks).toHaveLength(4);
     expect(result.tasks[0]).toContain("validation workflow");
-    expect(result.tasks[0]).toContain("skills/first-tree/assets/framework/workflows/validate.yml");
+    expect(result.tasks[0]).toContain(
+      ".agents/skills/first-tree/assets/framework/workflows/validate.yml",
+    );
     expect(result.tasks[1]).toContain("PR reviews");
     expect(result.tasks[2]).toContain("API secret");
     expect(result.tasks[3]).toContain("CODEOWNERS");
@@ -252,7 +273,7 @@ describe("ciValidation rule", () => {
     mkdirSync(wfDir, { recursive: true });
     writeFileSync(
       join(wfDir, "pr-review.yml"),
-      "name: PR Review\non: pull_request\njobs:\n  review:\n    steps:\n      - run: npx tsx skills/first-tree/assets/framework/helpers/run-review.ts\n",
+      "name: PR Review\non: pull_request\njobs:\n  review:\n    steps:\n      - run: npx tsx .agents/skills/first-tree/assets/framework/helpers/run-review.ts\n",
     );
     const repo = new Repo(tmp.path);
     const result = ciValidation.evaluate(repo);
@@ -271,7 +292,7 @@ describe("ciValidation rule", () => {
     );
     writeFileSync(
       join(wfDir, "pr-review.yml"),
-      "name: PR Review\non: pull_request\njobs:\n  review:\n    steps:\n      - run: npx tsx skills/first-tree/assets/framework/helpers/run-review.ts\n",
+      "name: PR Review\non: pull_request\njobs:\n  review:\n    steps:\n      - run: npx tsx .agents/skills/first-tree/assets/framework/helpers/run-review.ts\n",
     );
     const repo = new Repo(tmp.path);
     const result = ciValidation.evaluate(repo);
@@ -289,11 +310,11 @@ describe("ciValidation rule", () => {
     );
     writeFileSync(
       join(wfDir, "pr-review.yml"),
-      "name: PR Review\non: pull_request\njobs:\n  review:\n    steps:\n      - run: npx tsx skills/first-tree/assets/framework/helpers/run-review.ts\n",
+      "name: PR Review\non: pull_request\njobs:\n  review:\n    steps:\n      - run: npx tsx .agents/skills/first-tree/assets/framework/helpers/run-review.ts\n",
     );
     writeFileSync(
       join(wfDir, "codeowners.yml"),
-      "name: Update CODEOWNERS\non: pull_request\njobs:\n  update:\n    steps:\n      - run: npx tsx skills/first-tree/assets/framework/helpers/generate-codeowners.ts\n",
+      "name: Update CODEOWNERS\non: pull_request\njobs:\n  update:\n    steps:\n      - run: npx tsx .agents/skills/first-tree/assets/framework/helpers/generate-codeowners.ts\n",
     );
     const repo = new Repo(tmp.path);
     const result = ciValidation.evaluate(repo);
@@ -365,9 +386,9 @@ 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"));
+    mkdirSync(join(tmp.path, ".claude"), { recursive: true });
     writeFileSync(
       join(tmp.path, ".claude", "settings.json"),
       '{"hooks": {"inject-tree-context": true}}',