first-tree 0.0.2 → 0.0.3

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

@@ -0,0 +1,307 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+
+const ROOT = process.cwd();
+
+/** Check if a path has any tracked files in git (handles dirs and files). */
+function isTrackedInGit(relativePath: string): boolean {
+  const result = spawnSync("git", ["ls-files", relativePath], {
+    cwd: ROOT,
+    stdio: "pipe",
+  });
+  return (result.stdout?.toString().trim().length ?? 0) > 0;
+}
+
+describe("skill artifacts", () => {
+  it("keeps only the canonical skill in the source repo", () => {
+    expect(existsSync(join(ROOT, "skills", "first-tree", "SKILL.md"))).toBe(true);
+    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, "skills", "first-tree", "tests", "init.test.ts"))).toBe(
+      true,
+    );
+    expect(
+      existsSync(
+        join(ROOT, "evals", "context-tree-eval.test.ts"),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "engine",
+          "runtime",
+          "asset-loader.ts",
+        ),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "engine",
+          "rules",
+          "index.ts",
+        ),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "engine",
+          "validators",
+          "nodes.ts",
+        ),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "references",
+          "maintainer-architecture.md",
+        ),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "references",
+          "maintainer-thin-cli.md",
+        ),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "references",
+          "maintainer-build-and-distribution.md",
+        ),
+      ),
+    ).toBe(true);
+    expect(
+      existsSync(
+        join(
+          ROOT,
+          "skills",
+          "first-tree",
+          "references",
+          "maintainer-testing.md",
+        ),
+      ),
+    ).toBe(true);
+    // Legacy artifacts must not be tracked in git (untracked local files are OK)
+    expect(isTrackedInGit(".agents")).toBe(false);
+    expect(isTrackedInGit(".claude")).toBe(false);
+    expect(isTrackedInGit(".context-tree")).toBe(false);
+    expect(isTrackedInGit("skills/first-tree-cli-framework")).toBe(false);
+    expect(isTrackedInGit("docs")).toBe(false);
+    expect(isTrackedInGit("tests")).toBe(false);
+    expect(existsSync(join(ROOT, "evals"))).toBe(true);
+    expect(existsSync(join(ROOT, "src", "commands"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "runtime"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "rules"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "validators"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "init.ts"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "verify.ts"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "upgrade.ts"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "repo.ts"))).toBe(false);
+    expect(existsSync(join(ROOT, "src", "onboarding.ts"))).toBe(false);
+    expect(
+      existsSync(join(ROOT, "skills", "first-tree", "references", "repo-snapshot")),
+    ).toBe(false);
+    expect(existsSync(join(ROOT, "skills", "first-tree", "evals"))).toBe(false);
+  });
+
+  it("passes skill validation helpers", () => {
+    execFileSync(
+      "python3",
+      ["./skills/first-tree/scripts/quick_validate.py", "./skills/first-tree"],
+      {
+        cwd: ROOT,
+        stdio: "pipe",
+        encoding: "utf-8",
+      },
+    );
+    execFileSync("bash", ["./skills/first-tree/scripts/check-skill-sync.sh"], {
+      cwd: ROOT,
+      stdio: "pipe",
+      encoding: "utf-8",
+    });
+  });
+
+  it("ships the canonical skill in the published tarball", () => {
+    const packDir = mkdtempSync(join(tmpdir(), "first-tree-pack-"));
+    try {
+      const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8")) as {
+        name: string;
+        version: string;
+      };
+      execFileSync("pnpm", ["pack", "--pack-destination", packDir], {
+        cwd: ROOT,
+        stdio: "pipe",
+        encoding: "utf-8",
+      });
+
+      const tarball = join(packDir, `${pkg.name}-${pkg.version}.tgz`);
+      const listing = execFileSync("tar", ["-tf", tarball], {
+        cwd: ROOT,
+        stdio: "pipe",
+        encoding: "utf-8",
+      });
+
+      expect(listing).toContain("package/dist/cli.js");
+      expect(listing).toContain("package/skills/first-tree/SKILL.md");
+      expect(listing).toContain(
+        "package/skills/first-tree/agents/openai.yaml",
+      );
+      expect(listing).toContain(
+        "package/skills/first-tree/engine/init.ts",
+      );
+      expect(listing).toContain(
+        "package/skills/first-tree/tests/init.test.ts",
+      );
+      expect(listing).not.toContain("package/skills/first-tree/evals/");
+      expect(listing).not.toContain("package/evals/");
+      expect(listing).not.toContain("package/src/cli.ts");
+      expect(listing).not.toContain("package/docs/");
+    } finally {
+      rmSync(packDir, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps naming and installation guidance aligned", () => {
+    const read = (path: string) => readFileSync(join(ROOT, path), "utf-8");
+
+    expect(read("README.md")).not.toContain("seed-tree");
+    expect(read("AGENTS.md")).not.toContain("seed-tree");
+    expect(read("README.md")).toContain("Package Name vs Command");
+    expect(read("README.md")).toContain("Canonical Documentation");
+    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("`first-tree` skill");
+    expect(read("AGENTS.md")).toContain("references/source-map.md");
+    expect(read("AGENTS.md")).toContain("bundled skill path");
+    expect(read("AGENTS.md")).not.toContain("### Running evals");
+    expect(read("AGENTS.md")).not.toContain("EVALS_TREE_REPO");
+    expect(read("src/cli.ts")).not.toContain("from upstream");
+    // Note: #evals/* import alias is in package.json but evals/ is excluded from "files" so it won't ship to npm
+
+    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("installed CLI command is");
+    expect(onboarding).toContain("currently running `first-tree` npm package");
+    expect(onboarding).toContain("npx first-tree@latest upgrade");
+    expect(onboarding).not.toContain("This clones the framework into `.context-tree/`");
+    expect(onboarding).not.toContain("from upstream");
+
+    const skillMd = read("skills/first-tree/SKILL.md");
+    expect(skillMd).not.toContain("sync-skill-artifacts.sh");
+    expect(skillMd).not.toContain("portable-smoke-test.sh");
+    expect(skillMd).toContain("maintainer-build-and-distribution.md");
+    expect(skillMd).toContain("maintainer-testing.md");
+    expect(skillMd).toContain("currently running `first-tree` package");
+    expect(skillMd).toContain("so it is not confused with the `first-tree`");
+    expect(skillMd).not.toContain("canonical eval harness");
+
+    const sourceMap = read("skills/first-tree/references/source-map.md");
+    expect(sourceMap).not.toContain("repo-snapshot");
+    expect(sourceMap).not.toContain("sync-skill-artifacts.sh");
+    expect(sourceMap).toContain("maintainer-architecture.md");
+    expect(sourceMap).toContain("maintainer-thin-cli.md");
+    expect(sourceMap).toContain("maintainer-build-and-distribution.md");
+    expect(sourceMap).toContain("maintainer-testing.md");
+    expect(sourceMap).toContain("engine/commands/");
+    expect(sourceMap).toContain("engine/runtime/asset-loader.ts");
+    expect(sourceMap).toContain("tests/init.test.ts");
+    expect(sourceMap).toContain("tests/thin-cli.test.ts");
+    expect(sourceMap).not.toContain("evals/context-tree-eval.test.ts");
+    expect(sourceMap).toContain("package.json");
+    expect(sourceMap).not.toContain("vitest.eval.config.ts");
+    expect(sourceMap).toContain(".github/workflows/ci.yml");
+
+    const maintainerArchitecture = read(
+      "skills/first-tree/references/maintainer-architecture.md",
+    );
+    expect(maintainerArchitecture).toContain("maintainer-only developer tooling");
+    expect(maintainerArchitecture).toContain("`evals/`");
+    expect(maintainerArchitecture).not.toContain("tests, and evals");
+  });
+
+  it("keeps public OSS entrypoints and package metadata in place", () => {
+    const read = (path: string) => readFileSync(join(ROOT, path), "utf-8");
+    const pkg = JSON.parse(read("package.json")) as {
+      homepage?: string;
+      bugs?: { url?: string };
+      repository?: { type?: string; url?: string };
+      keywords?: string[];
+    };
+
+    expect(read("README.md")).toContain("Package Name vs Command");
+    expect(read("README.md")).toContain("CONTRIBUTING.md");
+    expect(read("README.md")).toContain("CODE_OF_CONDUCT.md");
+    expect(read("README.md")).toContain("SECURITY.md");
+
+    expect(read("CONTRIBUTING.md")).toContain("pnpm validate:skill");
+    expect(read("CONTRIBUTING.md")).toContain("pull request template");
+    expect(read("CONTRIBUTING.md")).toContain("source-map.md");
+    expect(read("CODE_OF_CONDUCT.md")).toContain("private maintainer follow-up");
+    expect(read("SECURITY.md")).toContain("Private Vulnerability Reporting");
+    expect(read("SECURITY.md")).toContain("do not post exploit details");
+
+    expect(existsSync(join(ROOT, ".github", "PULL_REQUEST_TEMPLATE.md"))).toBe(true);
+
+    const bugTemplate = parse(read(".github/ISSUE_TEMPLATE/bug-report.yml")) as {
+      name?: string;
+      body?: unknown[];
+    };
+    const featureTemplate = parse(read(".github/ISSUE_TEMPLATE/feature-request.yml")) as {
+      name?: string;
+      body?: unknown[];
+    };
+    const issueConfig = parse(read(".github/ISSUE_TEMPLATE/config.yml")) as {
+      contact_links?: unknown[];
+    };
+
+    expect(bugTemplate.name).toBe("Bug report");
+    expect(Array.isArray(bugTemplate.body)).toBe(true);
+    expect(featureTemplate.name).toBe("Feature request");
+    expect(Array.isArray(featureTemplate.body)).toBe(true);
+    expect(Array.isArray(issueConfig.contact_links)).toBe(true);
+    expect(issueConfig.contact_links).toHaveLength(3);
+
+    expect(pkg.homepage).toBe("https://github.com/agent-team-foundation/first-tree#readme");
+    expect(pkg.bugs).toEqual({
+      url: "https://github.com/agent-team-foundation/first-tree/issues",
+    });
+    expect(pkg.repository).toEqual({
+      type: "git",
+      url: "git+https://github.com/agent-team-foundation/first-tree.git",
+    });
+    expect(pkg.keywords).toEqual(
+      expect.arrayContaining(["context-tree", "cli", "agents"]),
+    );
+  });
+});

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

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { USAGE, runCli } from "../../../src/cli.ts";
+
+const ROOT = process.cwd();
+
+function captureOutput(): { lines: string[]; write: (text: string) => void } {
+  const lines: string[] = [];
+  return {
+    lines,
+    write: (text: string) => {
+      lines.push(text);
+    },
+  };
+}
+
+describe("thin CLI shell", () => {
+  it("prints usage with no args", async () => {
+    const output = captureOutput();
+
+    const code = await runCli([], output.write);
+
+    expect(code).toBe(0);
+    expect(output.lines).toEqual([USAGE]);
+  });
+
+  it("prints the package version", async () => {
+    const output = captureOutput();
+    const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8")) as {
+      version: string;
+    };
+
+    const code = await runCli(["--version"], output.write);
+
+    expect(code).toBe(0);
+    expect(output.lines).toEqual([pkg.version]);
+  });
+
+  it("routes help onboarding through the CLI entrypoint", async () => {
+    const output = captureOutput();
+
+    const code = await runCli(["help", "onboarding"], output.write);
+
+    expect(code).toBe(0);
+    expect(output.lines.join("\n")).toContain("# Context Tree Onboarding");
+    expect(output.lines.join("\n")).toContain("Node.js 18+");
+  });
+
+  it("fails with usage for an unknown command", async () => {
+    const output = captureOutput();
+
+    const code = await runCli(["wat"], output.write);
+
+    expect(code).toBe(1);
+    expect(output.lines[0]).toBe("Unknown command: wat");
+    expect(output.lines[1]).toBe(USAGE);
+  });
+});

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

@@ -0,0 +1,89 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } 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 {
+  FRAMEWORK_VERSION,
+  INSTALLED_PROGRESS,
+} from "#skill/engine/runtime/asset-loader.js";
+import {
+  makeFramework,
+  makeLegacyFramework,
+  makeLegacyNamedFramework,
+  makeSourceSkill,
+  useTmpDir,
+} from "./helpers.js";
+
+describe("runUpgrade", () => {
+  it("migrates a legacy repo to the installed skill layout", () => {
+    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",
+    );
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const result = runUpgrade(new Repo(repoDir.path), {
+      sourceRoot: sourceDir.path,
+    });
+
+    expect(result).toBe(0);
+    expect(existsSync(join(repoDir.path, ".context-tree"))).toBe(false);
+    expect(readFileSync(join(repoDir.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.2.0");
+    expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
+      "skills/first-tree/assets/framework/VERSION",
+    );
+  });
+
+  it("returns early when the installed skill already matches the packaged skill", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    makeFramework(repoDir.path, "0.2.0");
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const result = runUpgrade(new Repo(repoDir.path), {
+      sourceRoot: sourceDir.path,
+    });
+
+    expect(result).toBe(0);
+    expect(existsSync(join(repoDir.path, INSTALLED_PROGRESS))).toBe(false);
+  });
+
+  it("migrates repos that still use the previous installed skill name", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    makeLegacyNamedFramework(repoDir.path, "0.2.0");
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const result = runUpgrade(new Repo(repoDir.path), {
+      sourceRoot: sourceDir.path,
+    });
+
+    expect(result).toBe(0);
+    expect(existsSync(join(repoDir.path, "skills", "first-tree-cli-framework"))).toBe(
+      false,
+    );
+    expect(readFileSync(join(repoDir.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.2.0");
+    expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
+      "skills/first-tree-cli-framework/",
+    );
+  });
+
+  it("refuses to replace a newer installed skill with an older packaged skill", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    makeFramework(repoDir.path, "0.3.0");
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const result = runUpgrade(new Repo(repoDir.path), {
+      sourceRoot: sourceDir.path,
+    });
+
+    expect(result).toBe(1);
+    expect(readFileSync(join(repoDir.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.3.0");
+    expect(existsSync(join(repoDir.path, INSTALLED_PROGRESS))).toBe(false);
+  });
+});

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();
+  });
+});