first-tree 0.0.2 → 0.0.4

package/skills/first-tree/tests/validate-members.test.ts

@@ -0,0 +1,224 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  extractScalar,
+  extractList,
+  validateMember,
+  runValidateMembers,
+} from "#skill/engine/validators/members.js";
+import { useTmpDir } from "./helpers.js";
+
+function write(root: string, relPath: string, content: string): string {
+  const p = join(root, relPath);
+  mkdirSync(join(p, ".."), { recursive: true });
+  writeFileSync(p, content);
+  return p;
+}
+
+const VALID_MEMBER = `---
+title: Alice
+owners: [alice]
+type: human
+role: Engineer
+domains: [engineering]
+---
+# Alice
+`;
+
+const VALID_ASSISTANT = `---
+title: Alice Assistant
+owners: [alice]
+type: personal_assistant
+role: Assistant
+domains: [engineering]
+---
+# Alice Assistant
+`;
+
+// --- validateMember ---
+
+describe("validateMember", () => {
+  it("accepts valid member", () => {
+    const tmp = useTmpDir();
+    const p = write(tmp.path, "members/alice/NODE.md", VALID_MEMBER);
+    expect(validateMember(p, tmp.path)).toEqual([]);
+  });
+
+  it("reports missing title", () => {
+    const tmp = useTmpDir();
+    const content = "---\nowners: [alice]\ntype: human\nrole: Eng\ndomains: [eng]\n---\n";
+    const p = write(tmp.path, "members/alice/NODE.md", content);
+    const errors = validateMember(p, tmp.path);
+    expect(errors.some((e) => e.includes("title"))).toBe(true);
+  });
+
+  it("reports missing type", () => {
+    const tmp = useTmpDir();
+    const content = "---\ntitle: Alice\nowners: [alice]\nrole: Eng\ndomains: [eng]\n---\n";
+    const p = write(tmp.path, "members/alice/NODE.md", content);
+    const errors = validateMember(p, tmp.path);
+    expect(errors.some((e) => e.includes("type"))).toBe(true);
+  });
+
+  it("reports invalid type", () => {
+    const tmp = useTmpDir();
+    const content = "---\ntitle: Alice\nowners: [alice]\ntype: robot\nrole: Eng\ndomains: [eng]\n---\n";
+    const p = write(tmp.path, "members/alice/NODE.md", content);
+    const errors = validateMember(p, tmp.path);
+    expect(errors.some((e) => e.includes("invalid type"))).toBe(true);
+  });
+
+  it("reports missing domains", () => {
+    const tmp = useTmpDir();
+    const content = "---\ntitle: Alice\nowners: [alice]\ntype: human\nrole: Eng\n---\n";
+    const p = write(tmp.path, "members/alice/NODE.md", content);
+    const errors = validateMember(p, tmp.path);
+    expect(errors.some((e) => e.includes("domains"))).toBe(true);
+  });
+});
+
+// --- runValidateMembers: recursive scanning ---
+
+describe("runValidateMembers", () => {
+  it("validates nested members recursively", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", VALID_MEMBER);
+    write(tmp.path, "members/team-a/NODE.md", `---\ntitle: Team A\nowners: [lead]\ntype: autonomous_agent\nrole: Team Lead\ndomains: [engineering]\n---\n`);
+    write(tmp.path, "members/team-a/bot-1/NODE.md", `---\ntitle: Bot 1\nowners: [lead]\ntype: autonomous_agent\nrole: Worker\ndomains: [engineering]\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toEqual([]);
+  });
+
+  it("detects duplicate directory names across levels", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", VALID_MEMBER);
+    // Same name "alice" nested under team-a
+    write(tmp.path, "members/team-a/NODE.md", `---\ntitle: Team A\nowners: [lead]\ntype: autonomous_agent\nrole: Lead\ndomains: [eng]\n---\n`);
+    write(tmp.path, "members/team-a/alice/NODE.md", `---\ntitle: Alice Clone\nowners: [alice2]\ntype: human\nrole: Eng\ndomains: [eng]\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.some((e) => e.includes("Duplicate member directory name 'alice'"))).toBe(true);
+  });
+
+  it("reports missing NODE.md in nested directories", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", VALID_MEMBER);
+    // Create directory without NODE.md
+    mkdirSync(join(tmp.path, "members/team-a/orphan"), { recursive: true });
+    write(tmp.path, "members/team-a/NODE.md", `---\ntitle: Team A\nowners: [lead]\ntype: autonomous_agent\nrole: Lead\ndomains: [eng]\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.some((e) => e.includes("orphan") && e.includes("missing NODE.md"))).toBe(true);
+  });
+
+  it("validates deeply nested members (3+ levels)", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/org/NODE.md", `---\ntitle: Org\nowners: [admin]\ntype: autonomous_agent\nrole: Org\ndomains: [all]\n---\n`);
+    write(tmp.path, "members/org/team-a/NODE.md", `---\ntitle: Team A\nowners: [lead]\ntype: autonomous_agent\nrole: Lead\ndomains: [eng]\n---\n`);
+    write(tmp.path, "members/org/team-a/bot-1/NODE.md", `---\ntitle: Bot 1\nowners: [lead]\ntype: autonomous_agent\nrole: Worker\ndomains: [eng]\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+// --- runValidateMembers: delegate_mention cross-validation ---
+
+describe("runValidateMembers delegate_mention", () => {
+  it("accepts valid delegate_mention to personal_assistant", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", `---\ntitle: Alice\nowners: [alice]\ntype: human\nrole: Eng\ndomains: [eng]\ndelegate_mention: alice-assistant\n---\n`);
+    write(tmp.path, "members/alice-assistant/NODE.md", VALID_ASSISTANT);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toEqual([]);
+  });
+
+  it("rejects delegate_mention to non-existent member", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", `---\ntitle: Alice\nowners: [alice]\ntype: human\nrole: Eng\ndomains: [eng]\ndelegate_mention: ghost\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.some((e) => e.includes("delegate_mention 'ghost'") && e.includes("non-existent"))).toBe(true);
+  });
+
+  it("rejects delegate_mention to non-personal_assistant member", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", `---\ntitle: Alice\nowners: [alice]\ntype: human\nrole: Eng\ndomains: [eng]\ndelegate_mention: bob\n---\n`);
+    write(tmp.path, "members/bob/NODE.md", `---\ntitle: Bob\nowners: [bob]\ntype: human\nrole: Eng\ndomains: [eng]\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.some((e) => e.includes("delegate_mention 'bob'") && e.includes("personal_assistant"))).toBe(true);
+  });
+
+  it("accepts delegate_mention to nested personal_assistant", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", `---\ntitle: Alice\nowners: [alice]\ntype: human\nrole: Eng\ndomains: [eng]\ndelegate_mention: helper\n---\n`);
+    write(tmp.path, "members/bots/NODE.md", `---\ntitle: Bots\nowners: [admin]\ntype: autonomous_agent\nrole: Group\ndomains: [infra]\n---\n`);
+    write(tmp.path, "members/bots/helper/NODE.md", `---\ntitle: Helper\nowners: [admin]\ntype: personal_assistant\nrole: Assistant\ndomains: [eng]\n---\n`);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("allows member without delegate_mention", () => {
+    const tmp = useTmpDir();
+    write(tmp.path, "members/NODE.md", "---\ntitle: Members\n---\n");
+    write(tmp.path, "members/alice/NODE.md", VALID_MEMBER);
+
+    const result = runValidateMembers(tmp.path);
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+// --- extractScalar ---
+
+describe("extractScalar", () => {
+  it("extracts regular value", () => {
+    expect(extractScalar("title: Hello World\nowners: [a]", "title")).toBe("Hello World");
+  });
+
+  it("extracts quoted value", () => {
+    expect(extractScalar('title: "Hello World"\nowners: [a]', "title")).toBe("Hello World");
+  });
+
+  it("returns null for missing key", () => {
+    expect(extractScalar("owners: [a]", "title")).toBeNull();
+  });
+});
+
+// --- extractList ---
+
+describe("extractList", () => {
+  it("extracts inline list", () => {
+    expect(extractList("domains: [eng, product]", "domains")).toEqual(["eng", "product"]);
+  });
+
+  it("extracts block list", () => {
+    expect(extractList("domains:\n  - eng\n  - product\n", "domains")).toEqual(["eng", "product"]);
+  });
+
+  it("handles empty list", () => {
+    expect(extractList("domains: []", "domains")).toEqual([]);
+  });
+
+  it("returns null for missing key", () => {
+    expect(extractList("owners: [a]", "domains")).toBeNull();
+  });
+});

package/skills/first-tree/tests/validate-nodes.test.ts

@@ -0,0 +1,198 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  Findings,
+  parseFrontmatter,
+  parseSoftLinks,
+  validateOwners,
+  validateFolders,
+  validateEmptyNodes,
+  validateTitleMismatch,
+  setTreeRoot,
+} from "#skill/engine/validators/nodes.js";
+import { useTmpDir } from "./helpers.js";
+
+function write(root: string, relPath: string, content: string): string {
+  const p = join(root, relPath);
+  mkdirSync(join(p, ".."), { recursive: true });
+  writeFileSync(p, content);
+  return p;
+}
+
+function setup(tmp: { path: string }): string {
+  setTreeRoot(tmp.path);
+  return tmp.path;
+}
+
+// --- parseFrontmatter ---
+
+describe("parseFrontmatter", () => {
+  it("parses valid frontmatter", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Hello\nowners: [alice]\n---\n# Hello\n");
+    const fm = parseFrontmatter(p);
+    expect(fm).not.toBeNull();
+    expect(fm).toContain("title: Hello");
+  });
+
+  it("returns null for missing frontmatter", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "# No frontmatter here\n");
+    expect(parseFrontmatter(p)).toBeNull();
+  });
+
+  it("returns null for malformed frontmatter", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Oops\nNo closing fence\n");
+    expect(parseFrontmatter(p)).toBeNull();
+  });
+});
+
+// --- parseSoftLinks ---
+
+describe("parseSoftLinks", () => {
+  it("parses inline format", () => {
+    expect(parseSoftLinks("owners: [alice]\nsoft_links: [/a, /b]")).toEqual(["/a", "/b"]);
+  });
+
+  it("parses block format", () => {
+    expect(parseSoftLinks("owners: [alice]\nsoft_links:\n  - /x\n  - /y\n")).toEqual(["/x", "/y"]);
+  });
+
+  it("handles empty inline", () => {
+    expect(parseSoftLinks("owners: [alice]\nsoft_links: []")).toEqual([]);
+  });
+
+  it("returns null when missing", () => {
+    expect(parseSoftLinks("owners: [alice]")).toBeNull();
+  });
+});
+
+// --- validateOwners ---
+
+describe("validateOwners", () => {
+  it("accepts valid owners", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [alice, bob]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toEqual([]);
+  });
+
+  it("accepts wildcard", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [*]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toEqual([]);
+  });
+
+  it("accepts empty inheritance", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: []\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toEqual([]);
+  });
+
+  it("rejects invalid username", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [not valid!]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toHaveLength(1);
+    expect(f.errors[0]).toContain("invalid owner");
+  });
+
+  it("rejects mixed wildcard", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [alice, *]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toHaveLength(1);
+    expect(f.errors[0]).toContain("wildcard");
+  });
+});
+
+// --- validateFolders ---
+
+describe("validateFolders", () => {
+  it("reports missing NODE.md", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    mkdirSync(join(root, "domain"));
+    const f = new Findings();
+    validateFolders(f);
+    expect(f.errors.some((e) => e.includes("missing NODE.md"))).toBe(true);
+  });
+
+  it("passes with valid folder", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    mkdirSync(join(root, "domain"));
+    writeFileSync(join(root, "domain", "NODE.md"), "---\nowners: [a]\n---\n# D\n");
+    const f = new Findings();
+    validateFolders(f);
+    expect(f.errors).toEqual([]);
+  });
+});
+
+// --- validateEmptyNodes ---
+
+describe("validateEmptyNodes", () => {
+  it("flags short body", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [a]\n---\n\n");
+    const f = new Findings();
+    validateEmptyNodes([p], f);
+    expect(f.warnings.some((w) => w.includes("little or no body content"))).toBe(true);
+  });
+
+  it("passes with adequate body", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const body = "This is a meaningful body with enough content to pass the threshold easily.";
+    const p = write(root, "NODE.md", `---\nowners: [a]\n---\n${body}\n`);
+    const f = new Findings();
+    validateEmptyNodes([p], f);
+    expect(f.warnings).toEqual([]);
+  });
+});
+
+// --- validateTitleMismatch ---
+
+describe("validateTitleMismatch", () => {
+  it("passes with matching title", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Hello World\nowners: [a]\n---\n# Hello World\n");
+    const f = new Findings();
+    validateTitleMismatch([p], f);
+    expect(f.warnings).toEqual([]);
+  });
+
+  it("flags mismatched title", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Hello\nowners: [a]\n---\n# Goodbye\n");
+    const f = new Findings();
+    validateTitleMismatch([p], f);
+    expect(f.warnings).toHaveLength(1);
+    expect(f.warnings[0]).toContain("differs from");
+  });
+});

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

@@ -0,0 +1,241 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runInit } from "#skill/engine/init.js";
+import { check, checkProgress, runVerify } from "#skill/engine/verify.js";
+import { Repo } from "#skill/engine/repo.js";
+import {
+  AGENT_INSTRUCTIONS_FILE,
+  INSTALLED_PROGRESS,
+  LEGACY_PROGRESS,
+} from "#skill/engine/runtime/asset-loader.js";
+import {
+  useTmpDir,
+  makeAgentsMd,
+  makeFramework,
+  makeLegacyFramework,
+  makeNode,
+  makeSourceRepo,
+  makeMembers,
+  makeSourceSkill,
+} from "./helpers.js";
+
+// --- check ---
+
+describe("check", () => {
+  it("returns true on pass", () => {
+    expect(check("my check", true)).toBe(true);
+  });
+
+  it("returns false on fail", () => {
+    expect(check("my check", false)).toBe(false);
+  });
+});
+
+// --- checkProgress ---
+
+describe("checkProgress", () => {
+  it("returns empty for no progress file", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual([]);
+  });
+
+  it("returns empty when all checked", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
+    writeFileSync(
+      join(tmp.path, INSTALLED_PROGRESS),
+      "# Progress\n- [x] Task one\n- [x] Task two\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual([]);
+  });
+
+  it("returns unchecked items", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
+    writeFileSync(
+      join(tmp.path, INSTALLED_PROGRESS),
+      "# Progress\n- [x] Done task\n- [ ] Pending task\n- [ ] Another pending\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual(["Pending task", "Another pending"]);
+  });
+
+  it("returns empty for empty progress", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
+    writeFileSync(join(tmp.path, INSTALLED_PROGRESS), "");
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual([]);
+  });
+
+  it("falls back to the legacy progress file", () => {
+    const tmp = useTmpDir();
+    makeLegacyFramework(tmp.path);
+    writeFileSync(
+      join(tmp.path, LEGACY_PROGRESS),
+      "# Progress\n- [ ] Legacy task\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual(["Legacy task"]);
+  });
+});
+
+// --- helpers for building a full repo ---
+
+function buildFullRepo(root: string): void {
+  mkdirSync(join(root, ".git"));
+  makeFramework(root);
+  writeFileSync(
+    join(root, "NODE.md"),
+    "---\ntitle: My Org\nowners: [alice]\n---\n# Content\n",
+  );
+  makeAgentsMd(root, { markers: true });
+  makeMembers(root, 1);
+}
+
+const passValidator = () => ({ exitCode: 0 });
+const failValidator = () => ({ exitCode: 1 });
+
+// --- runVerify — all passing ---
+
+describe("runVerify all passing", () => {
+  it("returns 0 when all checks pass", () => {
+    const tmp = useTmpDir();
+    buildFullRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(0);
+  });
+
+  it("passes after a real init flow when only the user tree remains to validate", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    mkdirSync(join(repoDir.path, ".git"));
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    expect(runInit(new Repo(repoDir.path), { sourceRoot: sourceDir.path })).toBe(0);
+
+    writeFileSync(
+      join(repoDir.path, "NODE.md"),
+      [
+        "---",
+        'title: "Example Tree"',
+        "owners: [alice]",
+        "---",
+        "",
+        "# Example Tree",
+        "",
+        "A repository initialized from the bundled skill for verification coverage.",
+        "",
+        "## Domains",
+        "",
+        "- **[members/](members/NODE.md)** — Team member definitions and responsibilities.",
+        "",
+      ].join("\n"),
+    );
+
+    const agentPath = join(repoDir.path, AGENT_INSTRUCTIONS_FILE);
+    writeFileSync(
+      agentPath,
+      `${readFileSync(agentPath, "utf-8").trim()}\n\nProject-specific verification instructions.\n`,
+    );
+
+    mkdirSync(join(repoDir.path, "members", "alice"), { recursive: true });
+    writeFileSync(
+      join(repoDir.path, "members", "alice", "NODE.md"),
+      [
+        "---",
+        'title: "Alice"',
+        "owners: [alice]",
+        'type: "human"',
+        'role: "Maintainer"',
+        "domains:",
+        '  - "members"',
+        "---",
+        "",
+        "# Alice",
+        "",
+        "## About",
+        "",
+        "Maintains the initialized tree and keeps the docs current.",
+        "",
+        "## Current Focus",
+        "",
+        "Validating the init-to-verify workflow.",
+        "",
+      ].join("\n"),
+    );
+
+    const progressPath = join(repoDir.path, INSTALLED_PROGRESS);
+    writeFileSync(
+      progressPath,
+      readFileSync(progressPath, "utf-8").replace(/^- \[ \]/gm, "- [x]"),
+    );
+
+    expect(runVerify(new Repo(repoDir.path))).toBe(0);
+  });
+});
+
+// --- runVerify — failing checks ---
+
+describe("runVerify failing", () => {
+  it("fails on empty repo", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(1);
+  });
+
+  it("fails when AGENTS.md is missing", () => {
+    const tmp = useTmpDir();
+    makeFramework(tmp.path);
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "---\ntitle: My Org\nowners: [alice]\n---\n",
+    );
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(1);
+  });
+
+  it("fails when only legacy AGENT.md exists", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, ".git"));
+    makeFramework(tmp.path);
+    makeNode(tmp.path);
+    makeAgentsMd(tmp.path, { legacyName: true, markers: true, userContent: true });
+    makeMembers(tmp.path, 1);
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(existsSync(join(tmp.path, AGENT_INSTRUCTIONS_FILE))).toBe(false);
+    expect(ret).toBe(1);
+  });
+
+  it("fails when legacy AGENT.md remains alongside AGENTS.md", () => {
+    const tmp = useTmpDir();
+    buildFullRepo(tmp.path);
+    makeAgentsMd(tmp.path, { legacyName: true, markers: true, userContent: true });
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(1);
+  });
+
+  it("fails when node validation returns non-zero", () => {
+    const tmp = useTmpDir();
+    buildFullRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, failValidator);
+    expect(ret).toBe(1);
+  });
+
+  it("gives a dedicated-tree hint when run from a source repo", () => {
+    const tmp = useTmpDir();
+    makeSourceRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(1);
+  });
+});