@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/collective/global-skills.test.mjs

@@ -1,126 +0,0 @@
-/**
- * global-skills.test.mjs — the skills-install plan for ~/.claude/skills.
- * Run: node --test lib/collective/global-skills.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, lstatSync, readlinkSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { planSkillInstall, isGlobalInstall, installSkills, GLOBAL_SKILL_PREFIX } from "./global-skills.mjs";
-
-test("isGlobalInstall: true under the global npm root (or a node_modules path outside the agent repo)", () => {
-  assert.equal(isGlobalInstall("/opt/homebrew/lib/node_modules/@cohortapp/agent-sdk", { globalRoot: "/opt/homebrew/lib/node_modules" }), true);
-  assert.equal(isGlobalInstall("/Users/a/alex-ai/node_modules/@cohortapp/agent-sdk", { globalRoot: "/opt/homebrew/lib/node_modules" }), false);
-  assert.equal(isGlobalInstall("/Users/a/maestro", { globalRoot: "/opt/homebrew/lib/node_modules" }), false);
-  assert.equal(isGlobalInstall("/Users/a/maestro", { globalRoot: "" }), false, "unknown global root → copy");
-  assert.equal(isGlobalInstall("", { globalRoot: "/x" }), false);
-});
-
-test("planSkillInstall: one maestro-<name>/SKILL.md per skill file, mode symlink|copy", () => {
-  const plan = planSkillInstall(["org-board.md", "main-session.md", "README.md", "notes.txt", ".hidden.md"], {
-    sdkRoot: "/sdk", skillsDir: "/home/.claude/skills", mode: "symlink",
-  });
-  assert.deepEqual(plan.map((p) => p.name), ["org-board", "main-session"], "README/non-md/hidden skipped");
-  assert.equal(plan[0].src, "/sdk/plugins/maestro-skills/skills/org-board.md");
-  assert.equal(plan[0].dest, `/home/.claude/skills/${GLOBAL_SKILL_PREFIX}org-board/SKILL.md`);
-  assert.equal(plan[0].mode, "symlink");
-  assert.equal(planSkillInstall(["a.md"], { sdkRoot: "/s", skillsDir: "/d", mode: "copy" })[0].mode, "copy");
-});
-
-test("installSkills: copy mode writes files, symlink mode links, both idempotent and refresh on re-run", () => {
-  const root = mkdtempSync(join(tmpdir(), "global-skills-"));
-  try {
-    const sdk = join(root, "sdk");
-    const skillsSrc = join(sdk, "plugins", "maestro-skills", "skills");
-    mkdirSync(skillsSrc, { recursive: true });
-    writeFileSync(join(skillsSrc, "main-session.md"), "---\nname: main-session\n---\nbody v1\n");
-    writeFileSync(join(skillsSrc, "board-work.md"), "---\nname: board-work\n---\nbw\n");
-    const skillsDir = join(root, "home", ".claude", "skills");
-
-    const r1 = installSkills({ sdkRoot: sdk, skillsDir, mode: "copy" });
-    assert.equal(r1.ok, true);
-    assert.deepEqual(r1.installed.sort(), ["board-work", "main-session"]);
-    assert.equal(r1.unchanged.length, 0);
-    assert.equal(readFileSync(join(skillsDir, "maestro-main-session", "SKILL.md"), "utf8"), "---\nname: main-session\n---\nbody v1\n");
-
-    const r2 = installSkills({ sdkRoot: sdk, skillsDir, mode: "copy" });
-    assert.equal(r2.installed.length, 0, "idempotent");
-    assert.equal(r2.unchanged.length, 2);
-
-    writeFileSync(join(skillsSrc, "main-session.md"), "---\nname: main-session\n---\nbody v2\n");
-    const r3 = installSkills({ sdkRoot: sdk, skillsDir, mode: "copy" });
-    assert.deepEqual(r3.installed, ["main-session"], "a changed source refreshes the copy");
-    assert.match(readFileSync(join(skillsDir, "maestro-main-session", "SKILL.md"), "utf8"), /body v2/);
-
-    // Switch to symlink mode: replaces the copy with a link, then no-ops.
-    const r4 = installSkills({ sdkRoot: sdk, skillsDir, mode: "symlink" });
-    assert.equal(r4.installed.length, 2);
-    const link = join(skillsDir, "maestro-board-work", "SKILL.md");
-    assert.ok(lstatSync(link).isSymbolicLink());
-    assert.equal(readlinkSync(link), join(skillsSrc, "board-work.md"));
-    const r5 = installSkills({ sdkRoot: sdk, skillsDir, mode: "symlink" });
-    assert.equal(r5.installed.length, 0);
-    assert.equal(r5.unchanged.length, 2);
-
-    // Dry run touches nothing.
-    rmSync(skillsDir, { recursive: true, force: true });
-    const dry = installSkills({ sdkRoot: sdk, skillsDir, mode: "copy", dryRun: true });
-    assert.equal(dry.installed.length, 2);
-    assert.equal(existsSync(skillsDir), false);
-
-    // Missing source dir → ok:false with a reason, never a throw.
-    const none = installSkills({ sdkRoot: join(root, "nope"), skillsDir, mode: "copy" });
-    assert.equal(none.ok, false);
-    assert.match(none.error, /skills/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-// ── Review fix: {{agent.*}} tokens must be rendered for Claude-Code-loaded skills ─
-// Only the cadence consumer rendered templates; a skill installed into
-// ~/.claude/skills read "You are `{{agent.firstName}}`'s main session". A symlink
-// cannot render, so a token-bearing skill is rendered + COPIED even under a
-// global install; token-free skills keep the symlink.
-
-test("installSkills: with a render context, token-bearing skills are rendered and copied (even in symlink mode); token-free skills stay symlinks; a changed identity refreshes the copy", () => {
-  const root = mkdtempSync(join(tmpdir(), "global-skills-render-"));
-  try {
-    const sdk = join(root, "sdk");
-    const skillsSrc = join(sdk, "plugins", "maestro-skills", "skills");
-    mkdirSync(skillsSrc, { recursive: true });
-    writeFileSync(join(skillsSrc, "main-session.md"), "---\nname: main-session\n---\nYou are `{{agent.firstName}}`'s main session at {{company.name}}.\n");
-    writeFileSync(join(skillsSrc, "persona-discipline.md"), "---\nname: persona-discipline\n---\nYou are `{{agent.fullName}}`, `{{agent.title}}`. Unknown {{agent.nope}} stays.\n");
-    writeFileSync(join(skillsSrc, "board-work.md"), "---\nname: board-work\n---\nno tokens here\n");
-    const skillsDir = join(root, "home", ".claude", "skills");
-    const context = { agent: { firstName: "Alex", fullName: "Alex Rivera", title: "Chief of Staff" }, company: { name: "Acme" } };
-
-    const r1 = installSkills({ sdkRoot: sdk, skillsDir, mode: "symlink", context });
-    assert.equal(r1.ok, true);
-    assert.deepEqual(r1.installed.sort(), ["board-work", "main-session", "persona-discipline"]);
-    assert.deepEqual(r1.rendered.sort(), ["main-session", "persona-discipline"], "the token-bearing skills are reported as rendered");
-    const main = join(skillsDir, "maestro-main-session", "SKILL.md");
-    assert.equal(lstatSync(main).isSymbolicLink(), false, "rendered → a real file, never a link");
-    assert.equal(readFileSync(main, "utf8"), "---\nname: main-session\n---\nYou are `Alex`'s main session at Acme.\n");
-    assert.match(readFileSync(join(skillsDir, "maestro-persona-discipline", "SKILL.md"), "utf8"), /You are `Alex Rivera`, `Chief of Staff`\. Unknown \{\{agent\.nope\}\} stays\./);
-    assert.ok(lstatSync(join(skillsDir, "maestro-board-work", "SKILL.md")).isSymbolicLink(), "token-free → symlink");
-
-    const r2 = installSkills({ sdkRoot: sdk, skillsDir, mode: "symlink", context });
-    assert.equal(r2.installed.length, 0, "idempotent against the RENDERED content");
-    assert.equal(r2.unchanged.length, 3);
-
-    const r3 = installSkills({ sdkRoot: sdk, skillsDir, mode: "symlink", context: { agent: { firstName: "Robin", fullName: "Robin Park", title: "COO" }, company: { name: "Acme" } } });
-    assert.deepEqual(r3.installed.sort(), ["main-session", "persona-discipline"], "a new identity refreshes exactly the rendered skills");
-    assert.match(readFileSync(main, "utf8"), /`Robin`'s main session/);
-
-    // Copy mode renders too; no context → raw copy (previous behaviour).
-    const r4 = installSkills({ sdkRoot: sdk, skillsDir, mode: "copy", context });
-    assert.match(readFileSync(main, "utf8"), /`Alex`'s main session/);
-    assert.deepEqual(r4.rendered.sort(), ["main-session", "persona-discipline"]);
-    const r5 = installSkills({ sdkRoot: sdk, skillsDir, mode: "copy" });
-    assert.match(readFileSync(main, "utf8"), /\{\{agent\.firstName\}\}/, "no context → template left verbatim");
-    assert.deepEqual(r5.rendered, []);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});

package/lib/collective/presence.test.mjs

@@ -1,95 +0,0 @@
-/**
- * presence.test.mjs — tests for the concurrent-session presence registry.
- * Run: node --test lib/collective/presence.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { register, heartbeat, deregister, list, summarize } from "./presence.mjs";
-
-function tmp() {
-  return mkdtempSync(join(tmpdir(), "collective-presence-"));
-}
-const T0 = Date.parse("2026-06-03T12:00:00Z");
-
-test("register + list: round-trips a live session", () => {
-  const root = tmp();
-  try {
-    assert.equal(register(root, { sessionId: "s1", cwd: "/Users/x/maestro", intent: "triage inbox", nowMs: T0 }), true);
-    const live = list(root, { nowMs: T0 + 1000, staleSec: 300 });
-    assert.equal(live.length, 1);
-    assert.equal(live[0].sessionId, "s1");
-    assert.equal(live[0].repo, "maestro", "repo derived from cwd basename");
-    assert.equal(live[0].intent, "triage inbox");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("heartbeat: refreshes lastBeat and intent", () => {
-  const root = tmp();
-  try {
-    register(root, { sessionId: "s1", nowMs: T0 });
-    heartbeat(root, "s1", { nowMs: T0 + 60_000, intent: "drafting reply" });
-    const live = list(root, { nowMs: T0 + 61_000, staleSec: 300 });
-    assert.equal(live[0].intent, "drafting reply");
-    assert.equal(Date.parse(live[0].lastBeat), T0 + 60_000);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("deregister: removes the session", () => {
-  const root = tmp();
-  try {
-    register(root, { sessionId: "s1", nowMs: T0 });
-    deregister(root, "s1");
-    assert.equal(list(root, { nowMs: T0 + 1000 }).length, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("list: reaps stale sessions (no heartbeat past staleSec)", () => {
-  const root = tmp();
-  try {
-    register(root, { sessionId: "stale", nowMs: T0 });
-    // 10 min later with a 5-min stale window → reaped.
-    const live = list(root, { nowMs: T0 + 10 * 60_000, staleSec: 300 });
-    assert.equal(live.length, 0);
-    // Confirm it was actually deleted, not just filtered.
-    assert.equal(list(root, { nowMs: T0 + 10 * 60_000 + 1, staleSec: 999999 }).length, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("list: reaps dead-PID sessions", () => {
-  const root = tmp();
-  try {
-    register(root, { sessionId: "dead", pid: 2_000_000_000, nowMs: T0 });
-    const live = list(root, { nowMs: T0 + 1000, staleSec: 300 });
-    assert.equal(live.length, 0, "a session whose PID is not running is reaped");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("summarize: excludes self; empty when alone; formats others", () => {
-  const root = tmp();
-  try {
-    register(root, { sessionId: "me", cwd: "/x/maestro", nowMs: T0 });
-    assert.equal(summarize(root, { excludeSessionId: "me", nowMs: T0 + 1000 }), "", "alone → empty");
-    register(root, { sessionId: "other", cwd: "/x/openclaw", intent: "research", kind: "interactive", nowMs: T0 });
-    const line = summarize(root, { excludeSessionId: "me", nowMs: T0 + 1000, staleSec: 300 });
-    assert.match(line, /1 other session active/);
-    assert.match(line, /openclaw: research/);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/lib/collective/recall.test.mjs

@@ -1,116 +0,0 @@
-/**
- * recall.test.mjs — tests for the budgeted recall core.
- * Run: node --test lib/collective/recall.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  estimateTokens,
-  decayWeight,
-  rankCards,
-  mmrSelect,
-  selectWithinBudget,
-  formatDigest,
-  buildDigest,
-  recallForQuery,
-} from "./recall.mjs";
-
-const T = Date.parse("2026-06-03T12:00:00Z");
-const card = (over) => ({
-  id: over.id || over.title, ts: over.ts, kind: over.kind || "fact",
-  title: over.title, body: over.body || "", tags: over.tags || [],
-  salience: over.salience ?? 0.5, sessionId: "s", repo: "r", sourceRefs: [],
-});
-
-test("estimateTokens: ~chars/4", () => {
-  assert.equal(estimateTokens(""), 0);
-  assert.equal(estimateTokens("abcd"), 1);
-  assert.equal(estimateTokens("a".repeat(40)), 10);
-});
-
-test("decayWeight: 1.0 at age 0, ~0.5 at one half-life", () => {
-  assert.equal(decayWeight(0, 30), 1);
-  assert.ok(Math.abs(decayWeight(30 * 86400_000, 30) - 0.5) < 1e-9);
-  assert.ok(decayWeight(60 * 86400_000, 30) < 0.26);
-});
-
-test("rankCards: recency + salience order; relevanceById applies", () => {
-  const cards = [
-    card({ title: "old-hi-sal", ts: "2026-05-01T00:00:00Z", salience: 0.9 }),
-    card({ title: "new-lo-sal", ts: "2026-06-03T00:00:00Z", salience: 0.2 }),
-  ];
-  const ranked = rankCards(cards, { nowMs: T, halfLifeDays: 30 });
-  assert.equal(ranked[0].card.title, "new-lo-sal", "recent beats month-old even at lower salience");
-  // Relevance map can flip it.
-  const ranked2 = rankCards(cards, {
-    nowMs: T, halfLifeDays: 30,
-    relevanceById: { "old-hi-sal": 1, "new-lo-sal": 0.05 },
-  });
-  assert.equal(ranked2[0].card.title, "old-hi-sal", "strong relevance dominates");
-});
-
-test("mmrSelect: dedupes near-duplicates and respects limit", () => {
-  const scored = [
-    { card: card({ title: "Shipped the billing migration to prod" }), score: 1.0 },
-    { card: card({ title: "Shipped the billing migration to production" }), score: 0.99 },
-    { card: card({ title: "Hired a new compliance analyst" }), score: 0.8 },
-  ];
-  const picked = mmrSelect(scored, { limit: 2, lambda: 0.7 });
-  assert.equal(picked.length, 2);
-  const titles = picked.map((p) => p.card.title);
-  assert.ok(titles.includes("Shipped the billing migration to prod"));
-  assert.ok(
-    titles.includes("Hired a new compliance analyst"),
-    "MMR should prefer the diverse card over the near-duplicate",
-  );
-});
-
-test("selectWithinBudget: stops before exceeding the budget", () => {
-  const items = Array.from({ length: 50 }, (_, i) => ({ card: card({ title: `card number ${i} with some words` }), score: 1 - i / 100 }));
-  const tiny = selectWithinBudget(items, { budgetTokens: 20 });
-  const big = selectWithinBudget(items, { budgetTokens: 100000 });
-  assert.ok(tiny.length < big.length, "tighter budget selects fewer");
-  assert.ok(tiny.length >= 1);
-});
-
-test("formatDigest: empty when nothing; includes presence + cards", () => {
-  assert.equal(formatDigest({ presenceLine: "", cards: [] }), "");
-  const out = formatDigest({
-    presenceLine: "1 other session active — maestro: triage (2m)",
-    cards: [card({ title: "Decided to ship v2", kind: "decision" })],
-    totalCards: 3,
-  });
-  assert.match(out, /maestro:collective-digest/);
-  assert.match(out, /Active now:/);
-  assert.match(out, /Decided to ship v2/);
-  assert.match(out, /of 3/, "indicates more available");
-});
-
-test("buildDigest: budgeted, uses overrides, fail-open", () => {
-  const cards = Array.from({ length: 30 }, (_, i) =>
-    card({ title: `Event ${i} happened in the system today`, ts: "2026-06-03T00:00:00Z", salience: 0.5 }));
-  const full = buildDigest("/nonexistent", {
-    nowMs: T, budgetTokens: 100000, presenceLineOverride: "2 sessions active", cardsOverride: cards,
-  });
-  assert.match(full, /Active now:/);
-  const tight = buildDigest("/nonexistent", {
-    nowMs: T, budgetTokens: 60, presenceLineOverride: "2 sessions active", cardsOverride: cards,
-  });
-  // Tight budget yields a much shorter block.
-  assert.ok(tight.length < full.length);
-  // Fail-open: bad input never throws.
-  assert.equal(typeof buildDigest(null, { cardsOverride: null, presenceLineOverride: "" }), "string");
-});
-
-test("recallForQuery: injected search; empty without query", async () => {
-  assert.deepEqual(await recallForQuery({ agentRoot: "/x" }), []);
-  const hits = await recallForQuery({
-    agentRoot: "/x", query: "billing",
-    searchFn: async ({ query }) => [{ source_path: "memory/collective/cards/x.jsonl", relevance: 1, snippet: query }],
-  });
-  assert.equal(hits.length, 1);
-  assert.equal(hits[0].relevance, 1);
-});

package/lib/collective/vendor-skills.test.mjs

@@ -1,306 +0,0 @@
-/**
- * Tests for lib/collective/vendor-skills.mjs — installing the VENDORED design
- * skill packs into a seat's ~/.claude/skills.
- *
- * Three properties carry the weight, and each is pinned here:
- *
- *   1. **It installs under the frontmatter name**, not the directory name —
- *      `taste-skill/skills/soft-skill` is `high-end-visual-design` to every
- *      piece of prose that refers to it, including the harmoniser skill.
- *   2. **It is idempotent.** A second run over an unchanged tree writes
- *      nothing, because `global-setup` runs on every upgrade hop on 40+ seats.
- *   3. **It never clobbers a directory that is not ours.** A human who
- *      installed upstream `impeccable` themselves — launcher, hooks, live mode
- *      — keeps it, and the run says so instead of silently taking it away.
- *
- * The end-to-end cases run against the REAL vendored trees in a throwaway HOME,
- * because a plan that is right about a synthetic pack and wrong about
- * `emilkowalski`'s nested skill roots would ship.
- *
- * @module lib/collective/vendor-skills.test
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, existsSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  frontmatterName, ownership, planVendorSkills, installVendorSkills, markerFor,
-  packSize, looksLikeSkillsDir, MARKER_FILE, MARKER_OWNER,
-} from "./vendor-skills.mjs";
-import { PACKS, findPack } from "../../scripts/vendor/skill-packs.mjs";
-
-const SDK_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-/** A throwaway HOME. Returns {home, skillsDir, cleanup}. */
-function throwawayHome() {
-  const home = mkdtempSync(join(tmpdir(), "maestro-vendor-home-"));
-  return {
-    home,
-    skillsDir: join(home, ".claude", "skills"),
-    cleanup: () => rmSync(home, { recursive: true, force: true }),
-  };
-}
-
-describe("vendor-skills: pure helpers", () => {
-  it("frontmatterName reads the name and refuses a body that has none", () => {
-    assert.equal(frontmatterName("---\nname: impeccable\nversion: 4.3.1\n---\n# x"), "impeccable");
-    assert.equal(frontmatterName('---\nname: "quoted-name"\n---\n'), "quoted-name");
-    assert.equal(frontmatterName("# no frontmatter\n"), null);
-    assert.equal(frontmatterName("---\ndescription: no name here\n---\n"), null);
-  });
-
-  it("frontmatterName refuses a name that would escape the skills directory", () => {
-    assert.equal(frontmatterName("---\nname: ../../etc\n---\n"), null);
-    assert.equal(frontmatterName("---\nname: a/b\n---\n"), null);
-  });
-
-  it("looksLikeSkillsDir only accepts a path ending in skills/", () => {
-    assert.equal(looksLikeSkillsDir("/home/x/.claude/skills"), true);
-    assert.equal(looksLikeSkillsDir("/home/x/.claude"), false);
-  });
-
-  it("markerFor is deterministic — no clock, so a re-run writes nothing", () => {
-    const pack = findPack("unlazy");
-    assert.equal(markerFor(pack, "unlazy"), markerFor(pack, "unlazy"));
-    const doc = JSON.parse(markerFor(pack, "unlazy"));
-    assert.equal(doc.owner, MARKER_OWNER);
-    assert.equal(doc.sha, pack.sha);
-  });
-});
-
-describe("vendor-skills: ownership", () => {
-  it("reports absent / ours / foreign", () => {
-    const { home, cleanup } = throwawayHome();
-    try {
-      const absent = join(home, "nothing");
-      assert.equal(ownership(absent), "absent");
-
-      const foreign = join(home, "impeccable");
-      mkdirSync(foreign, { recursive: true });
-      writeFileSync(join(foreign, "SKILL.md"), "the human's own install\n");
-      assert.equal(ownership(foreign), "foreign");
-
-      const ours = join(home, "unlazy");
-      mkdirSync(ours, { recursive: true });
-      writeFileSync(join(ours, MARKER_FILE), markerFor(findPack("unlazy"), "unlazy"));
-      assert.equal(ownership(ours), "ours");
-
-      writeFileSync(join(ours, MARKER_FILE), "{not json");
-      assert.equal(ownership(ours), "foreign", "an unreadable marker is not proof of ownership");
-
-      writeFileSync(join(ours, MARKER_FILE), JSON.stringify({ owner: "someone-else" }));
-      assert.equal(ownership(ours), "foreign");
-    } finally { cleanup(); }
-  });
-});
-
-describe("vendor-skills: the plan over the real vendored trees", () => {
-  const { skills, errors } = planVendorSkills({ sdkRoot: SDK_ROOT, skillsDir: "/tmp/unused", packs: PACKS });
-
-  it("plans one skill per declared skill root, with no errors", () => {
-    assert.deepEqual(errors, [], "every pack's tree is present and every root has a SKILL.md");
-    const roots = PACKS.reduce((n, p) => n + p.skillRoots.length, 0);
-    assert.equal(skills.length, roots);
-  });
-
-  it("installs under the frontmatter name, not the directory name", () => {
-    const names = skills.map((s) => s.name);
-    for (const expected of [
-      "impeccable", "unlazy",
-      "emil-design-eng", "animate", "animation-vocabulary", "apple-design",
-      "find-animation-opportunities", "improve-animations", "review-animations", "prototype",
-      "design-taste-frontend", "redesign-existing-projects", "high-end-visual-design", "minimalist-ui",
-    ]) assert.ok(names.includes(expected), `expected skill ${expected}, got ${names.join(", ")}`);
-    assert.equal(new Set(names).size, names.length, "no two packs claim the same directory");
-  });
-
-  it("gives every skill a SKILL.md at its root and never a sibling skill's files", () => {
-    for (const s of skills) {
-      assert.ok(s.files.some((f) => f.to === "SKILL.md"), `${s.name} has SKILL.md at its root`);
-      assert.ok(s.files.every((f) => !f.to.startsWith("skills/")), `${s.name} carries no nested skills/ path`);
-    }
-    const animate = skills.find((s) => s.name === "animate");
-    assert.ok(animate.files.some((f) => f.to === "RECIPES.md"), "sibling reference file comes along");
-    assert.ok(animate.files.some((f) => f.to === "LICENSE"), "a sub-directory skill still ships its licence");
-    assert.ok(!animate.files.some((f) => f.to.includes("apple-design")), "a sibling skill's files stay out");
-  });
-
-  it("impeccable brings its reference tree, its subordinate briefs and its NOTICE", () => {
-    const imp = skills.find((s) => s.name === "impeccable");
-    assert.ok(imp.files.some((f) => f.to === "NOTICE.md"));
-    assert.ok(imp.files.some((f) => f.to.startsWith("reference/")));
-    assert.ok(imp.files.some((f) => f.to.startsWith("agents/impeccable-")));
-  });
-
-  it("a pack whose vendored tree is absent is an error, not a crash", () => {
-    const r = planVendorSkills({ sdkRoot: join(tmpdir(), "no-such-sdk-root"), skillsDir: "/tmp/unused", packs: PACKS });
-    assert.equal(r.skills.length, 0);
-    assert.equal(r.errors.length, PACKS.length);
-  });
-});
-
-describe("vendor-skills: install into a throwaway HOME", () => {
-  it("installs every pack skill, is idempotent, and heals a tampered file", () => {
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      const first = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS });
-      assert.deepEqual(first.errors, []);
-      assert.deepEqual(first.skipped, []);
-      assert.equal(first.unchanged.length, 0);
-      assert.ok(first.installed.length >= 14, `installed ${first.installed.length} skills`);
-
-      // The bytes landed, under the frontmatter name, with our marker.
-      const impeccable = join(skillsDir, "impeccable");
-      assert.ok(existsSync(join(impeccable, "SKILL.md")));
-      assert.ok(existsSync(join(impeccable, "reference", "critique.md")));
-      assert.ok(existsSync(join(impeccable, "LICENSE")));
-      assert.equal(ownership(impeccable), "ours");
-      assert.equal(statSync(join(impeccable, "SKILL.md")).mode & 0o777, 0o644);
-
-      const minimalist = join(skillsDir, "minimalist-ui");
-      assert.match(readFileSync(join(minimalist, "SKILL.md"), "utf8"), /name: minimalist-ui/);
-
-      // Second run: nothing written.
-      const second = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS });
-      assert.deepEqual(second.installed, [], "idempotent");
-      assert.equal(second.unchanged.length, first.installed.length);
-
-      // A locally edited file is restored; a stray file inside a directory we
-      // own is removed (it would otherwise be read as skill content forever).
-      writeFileSync(join(impeccable, "SKILL.md"), "tampered\n");
-      writeFileSync(join(impeccable, "stray.md"), "not upstream\n");
-      const third = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS });
-      assert.ok(third.installed.includes("impeccable"));
-      assert.match(readFileSync(join(impeccable, "SKILL.md"), "utf8"), /^---\nname: impeccable/);
-      assert.equal(existsSync(join(impeccable, "stray.md")), false);
-    } finally { cleanup(); }
-  });
-
-  it("leaves a FOREIGN directory exactly as it is and says which one", () => {
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      // The human installed upstream impeccable themselves — launcher and all.
-      const foreign = join(skillsDir, "impeccable");
-      mkdirSync(join(foreign, "scripts"), { recursive: true });
-      const own = "---\nname: impeccable\n---\nthe human's own copy, with its launcher\n";
-      writeFileSync(join(foreign, "SKILL.md"), own);
-      writeFileSync(join(foreign, "scripts", "impeccable"), "#!/bin/sh\n");
-
-      const r = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS });
-      assert.deepEqual(r.installed.includes("impeccable"), false, "not installed over the human's copy");
-      assert.equal(r.skipped.length, 1);
-      assert.equal(r.skipped[0].name, "impeccable");
-      assert.match(r.skipped[0].reason, /not maestro's/);
-      assert.equal(readFileSync(join(foreign, "SKILL.md"), "utf8"), own, "byte-for-byte untouched");
-      assert.ok(existsSync(join(foreign, "scripts", "impeccable")), "their launcher is still theirs");
-      // Every other pack still installed.
-      assert.ok(r.installed.includes("unlazy"));
-      assert.ok(existsSync(join(skillsDir, "unlazy", "SKILL.md")));
-    } finally { cleanup(); }
-  });
-
-  it("dryRun reports what it would do and writes nothing", () => {
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      const r = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS, dryRun: true });
-      assert.ok(r.installed.length > 0);
-      assert.equal(existsSync(skillsDir), false, "nothing written");
-    } finally { cleanup(); }
-  });
-
-  it("refuses a destination that is not a skills directory, and writes nothing", () => {
-    // The failure this pins: an unset variable interpolated to
-    // "undefined/home/.claude/skills" and a full 14-skill tree was created at
-    // ./undefined/ relative to the cwd, inside a repo checkout.
-    const home = mkdtempSync(join(tmpdir(), "maestro-vendor-bogus-"));
-    try {
-      const bogus = join(home, ".claude", "skulls");
-      const r = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir: bogus, packs: PACKS });
-      assert.equal(r.ok, false);
-      assert.deepEqual(r.installed, []);
-      assert.match(r.errors[0].error, /not a skills directory/);
-      assert.equal(existsSync(bogus), false, "nothing was created");
-    } finally { rmSync(home, { recursive: true, force: true }); }
-  });
-
-  it("refuses to install two packs into one skill name rather than letting one eat the other", () => {
-    // No collision exists today; the registry is meant to grow, and
-    // ownership() reads only the owner string, so the second pack would see
-    // "ours", delete the first pack's files as stale and report a normal
-    // install.
-    const fakeSdk = mkdtempSync(join(tmpdir(), "maestro-vendor-sdk-"));
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      const packs = ["alpha", "beta"].map((id) => {
-        const dir = join(fakeSdk, "plugins", "maestro-skills", "vendor", id);
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, "SKILL.md"), `---\nname: shared-skill\n---\nfrom ${id}\n`);
-        return { id, repo: `example/${id}`, sha: "0".repeat(40), license: "MIT", skillRoots: ["."] };
-      });
-      const r = planVendorSkills({ sdkRoot: fakeSdk, skillsDir, packs });
-      assert.equal(r.skills.length, 1, "only the first claim stands");
-      assert.equal(r.skills[0].pack.id, "alpha");
-      assert.ok(r.errors.some((e) => e.pack === "beta" && /already claimed by pack alpha/.test(e.error)), JSON.stringify(r.errors));
-
-      const inst = installVendorSkills({ sdkRoot: fakeSdk, skillsDir, packs });
-      assert.equal(inst.ok, false, "a collision is an error, not a silent overwrite");
-      assert.match(readFileSync(join(skillsDir, "shared-skill", "SKILL.md"), "utf8"), /from alpha/);
-    } finally { cleanup(); rmSync(fakeSdk, { recursive: true, force: true }); }
-  });
-
-  it("copies a directory aside before overwriting work somebody did in it", () => {
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS, stamp: "STAMP" });
-      const dir = join(skillsDir, "impeccable");
-      const tuned = "---\nname: impeccable\n---\ntuned for Cohort\n";
-      writeFileSync(join(dir, "SKILL.md"), tuned);
-      writeFileSync(join(dir, "cohort-notes.md"), "a person's own notes\n");
-
-      const r = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS, stamp: "STAMP" });
-      const b = r.backups.find((x) => x.name === "impeccable");
-      assert.ok(b, `expected a backup, got ${JSON.stringify(r.backups)}`);
-      assert.deepEqual(b.files.sort(), ["SKILL.md", "cohort-notes.md"]);
-      assert.equal(readFileSync(join(b.path, "SKILL.md"), "utf8"), tuned, "their edit survives");
-      assert.equal(readFileSync(join(b.path, "cohort-notes.md"), "utf8"), "a person's own notes\n");
-      // …and the live directory is back to the vendored bytes.
-      assert.match(readFileSync(join(dir, "SKILL.md"), "utf8"), /^---\nname: impeccable/);
-      assert.equal(existsSync(join(dir, "cohort-notes.md")), false);
-    } finally { cleanup(); }
-  });
-
-  it("backs nothing up when it only rewrites files it wrote itself", () => {
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      const first = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS, stamp: "STAMP" });
-      assert.deepEqual(first.backups, []);
-      const second = installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS, stamp: "STAMP" });
-      assert.deepEqual(second.backups, [], "an idempotent re-run leaves no backup directories behind");
-      assert.deepEqual(second.installed, []);
-    } finally { cleanup(); }
-  });
-
-  it("puts no hook machinery on the seat", () => {
-    const { skillsDir, cleanup } = throwawayHome();
-    try {
-      installVendorSkills({ sdkRoot: SDK_ROOT, skillsDir, packs: PACKS });
-      const unlazy = join(skillsDir, "unlazy");
-      assert.ok(existsSync(join(unlazy, "scripts", "gate-check.mjs")), "the gate checker is the reason scripts/ is vendored");
-      for (const name of ["install-hooks.mjs", "stop-hook.mjs"]) {
-        assert.equal(existsSync(join(unlazy, "scripts", name)), false,
-          `${name} would be one \`node <path>\` away from a Stop hook in the settings file every session reads`);
-      }
-    } finally { cleanup(); }
-  });
-
-  it("packSize reports a file count and a byte size for every pack", () => {
-    for (const pack of PACKS) {
-      const s = packSize(SDK_ROOT, pack);
-      assert.ok(s.files > 0, `${pack.id} has files`);
-      assert.ok(s.bytes > 0, `${pack.id} has bytes`);
-    }
-  });
-});