kennel 0.2.1 → 0.2.3

package/kernel/packages/agents/test/resolve.test.mjs

@@ -0,0 +1,729 @@
+import {
+  chmod,
+  mkdir,
+  mkdtemp,
+  realpath,
+  rm,
+  symlink,
+  writeFile,
+} from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { afterEach, describe, expect, test } from "bun:test"
+
+import { resolveAgents } from "../src/node.ts"
+
+const savedEnv = {}
+
+async function freshBase() {
+  return mkdtemp(join(tmpdir(), "kennel-agents-"))
+}
+
+async function repository(base) {
+  const repo = join(base, "repo")
+  await mkdir(join(repo, ".git"), { recursive: true })
+  return repo
+}
+
+function setEnv(name, value) {
+  if (!(name in savedEnv)) savedEnv[name] = process.env[name]
+  if (value === undefined) delete process.env[name]
+  else process.env[name] = value
+}
+
+const cleanup = []
+
+afterEach(async () => {
+  for (const name of Object.keys(savedEnv)) {
+    if (savedEnv[name] === undefined) delete process.env[name]
+    else process.env[name] = savedEnv[name]
+  }
+  for (const name of Object.keys(savedEnv)) delete savedEnv[name]
+  while (cleanup.length) {
+    const path = cleanup.pop()
+    if (path) await rm(path, { force: true, recursive: true })
+  }
+})
+
+describe("resolveAgents", () => {
+  test("generic walks to the filesystem root and includes instructions above .git", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".agents"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "mid", "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(repo, "mid", "AGENTS.md"), "# parent\n")
+    await writeFile(join(repo, "AGENTS.md"), "# repository\n")
+    await writeFile(join(base, "AGENTS.md"), "# above-git\n")
+    await writeFile(join(home, ".agents", "AGENTS.md"), "# global\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    expect(result.repositoryRoot).toBe(await realpath(repo))
+    expect(result.sources.map((source) => source.level)).toEqual([
+      "project",
+      "parent",
+      "parent",
+      "parent",
+      "global",
+    ])
+    expect(result.sources.map((source) => source.text).join("\n")).toContain(
+      "# above-git",
+    )
+    expect(result.sources[0].level).toBe("project")
+    expect(result.sources.at(-1).level).toBe("global")
+  })
+
+  test("the chain lists every ancestor directory going up, with and without files", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".agents"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "mid", "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(repo, "mid", "AGENTS.md"), "# parent\n")
+    await writeFile(join(home, ".agents", "AGENTS.md"), "# global\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    // The chain starts at the working folder and keeps deep-to-shallow
+    // ancestor order; directories without files stay listed.
+    const projectPath = await realpath(project)
+    const midPath = await realpath(join(repo, "mid"))
+    const repoPath = await realpath(repo)
+    expect(result.chain[0]).toMatchObject({
+      directory: projectPath,
+      level: "project",
+      filenames: ["AGENTS.md"],
+    })
+    const projectIndex = result.chain.findIndex(
+      (entry) => entry.directory === projectPath,
+    )
+    const midIndex = result.chain.findIndex(
+      (entry) => entry.directory === midPath,
+    )
+    const repoIndex = result.chain.findIndex(
+      (entry) => entry.directory === repoPath,
+    )
+    expect(projectIndex).toBe(0)
+    expect(projectIndex).toBeLessThan(midIndex)
+    expect(midIndex).toBeLessThan(repoIndex)
+    expect(result.chain[midIndex].filenames).toEqual(["AGENTS.md"])
+    expect(
+      result.chain.filter((entry) => entry.filenames.length === 0).length,
+    ).toBeGreaterThan(0)
+
+    // The global directory is not an ancestor, so it never appears in the
+    // chain even when it contains an instruction file.
+    const globalPath = await realpath(join(home, ".agents"))
+    expect(result.chain.some((entry) => entry.directory === globalPath)).toBe(
+      false,
+    )
+  })
+
+  test("the ancestor walk stops at the closest raggle.json workspace", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".agents"), { recursive: true })
+    const workspace = join(base, "workspace")
+    const project = join(workspace, "clients", "client-three")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(workspace, "raggle.json"), "{}\n")
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(base, "AGENTS.md"), "# above-workspace\n")
+    await writeFile(join(home, ".agents", "AGENTS.md"), "# global\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    const workspacePath = await realpath(workspace)
+    const basePath = await realpath(base)
+    // The chain ends exactly at the workspace root; nothing above it is
+    // walked, so its AGENTS.md is neither a chain entry nor a source.
+    expect(result.chain.at(-1).directory).toBe(workspacePath)
+    expect(result.chain.at(-1).level).toBe("parent")
+    expect(result.chain.some((entry) => entry.directory === basePath)).toBe(
+      false,
+    )
+    expect(result.sources.some((source) => source.directory === basePath)).toBe(
+      false,
+    )
+    expect(result.sources.map((source) => source.level)).toEqual([
+      "project",
+      "global",
+    ])
+  })
+
+  test("pi walks above the repository and prefers AGENTS.md over CLAUDE.md", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".pi", "agent"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# agents\n")
+    await writeFile(join(project, "CLAUDE.md"), "# claude\n")
+    await writeFile(join(base, "AGENTS.md"), "# above-git\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "pi",
+      homeDir: home,
+    })
+
+    expect(result.sources.map((source) => source.text).join("\n")).toContain(
+      "# above-git",
+    )
+    const projectSource = result.sources.find(
+      (source) => source.level === "project",
+    )
+    expect(projectSource.filename).toBe("AGENTS.md")
+    expect(
+      result.sources.some((source) => source.filename === "CLAUDE.md"),
+    ).toBe(false)
+  })
+
+  test("codex stops at the repository boundary and prefers AGENTS.override.md", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".codex"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# base\n")
+    await writeFile(join(project, "AGENTS.override.md"), "# override\n")
+    await writeFile(join(repo, "AGENTS.md"), "# repository\n")
+    await writeFile(join(base, "AGENTS.md"), "# above-git\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "codex",
+      homeDir: home,
+    })
+
+    const text = result.sources.map((source) => source.text).join("\n")
+    expect(text).toContain("# repository")
+    expect(text).not.toContain("# above-git")
+    expect(result.sources.map((source) => source.level)).toEqual([
+      "project",
+      "repository",
+    ])
+    const projectSource = result.sources[0]
+    expect(projectSource.filename).toBe("AGENTS.override.md")
+    expect(projectSource.override).toBe(true)
+    expect(text).not.toContain("# base")
+
+    // Codex's boundary is the git root: the chain ends there and never
+    // lists directories above the repository.
+    const repoPath = await realpath(repo)
+    const basePath = await realpath(base)
+    expect(result.chain.at(-1)).toMatchObject({
+      directory: repoPath,
+      level: "repository",
+    })
+    expect(result.chain.some((entry) => entry.directory === basePath)).toBe(
+      false,
+    )
+  })
+
+  test("pi global falls back to CLAUDE.md when AGENTS.md is absent", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".pi", "agent"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(home, ".pi", "agent", "CLAUDE.md"), "# pi-global\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "pi",
+      homeDir: home,
+    })
+
+    const global = result.sources.find((source) => source.level === "global")
+    expect(global.filename).toBe("CLAUDE.md")
+    expect(global.text).toContain("# pi-global")
+  })
+
+  test("codex global prefers AGENTS.override.md over AGENTS.md", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".codex"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(home, ".codex", "AGENTS.md"), "# codex-base\n")
+    await writeFile(
+      join(home, ".codex", "AGENTS.override.md"),
+      "# codex-override\n",
+    )
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "codex",
+      homeDir: home,
+    })
+
+    const global = result.sources.find((source) => source.level === "global")
+    expect(global.filename).toBe("AGENTS.override.md")
+    expect(global.text).toContain("# codex-override")
+  })
+
+  test("claude loads CLAUDE.md, .claude/CLAUDE.md, and CLAUDE.local.md per ancestor", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".claude"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(join(project, ".claude"), { recursive: true })
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "CLAUDE.md"), "# project\n")
+    await writeFile(join(project, ".claude", "CLAUDE.md"), "# project-dot\n")
+    await writeFile(join(project, "CLAUDE.local.md"), "# project-local\n")
+    await writeFile(join(home, ".claude", "CLAUDE.md"), "# claude-global\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "claude",
+      homeDir: home,
+    })
+
+    const filenames = result.sources.map((source) => source.filename)
+    expect(filenames).toContain("CLAUDE.md")
+    expect(filenames).toContain("CLAUDE.local.md")
+    const dotDirReal = await realpath(join(project, ".claude"))
+    const dotSource = result.sources.find(
+      (source) => source.directory === dotDirReal,
+    )
+    expect(dotSource).toBeTruthy()
+    expect(dotSource.filename).toBe("CLAUDE.md")
+    expect(result.sources.some((source) => source.level === "global")).toBe(
+      true,
+    )
+  })
+
+  test("a client filter changes discovery, not only the view", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".claude"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(project, "CLAUDE.md"), "# claude-project\n")
+
+    const codex = await resolveAgents({
+      folder: project,
+      client: "codex",
+      homeDir: home,
+    })
+    expect(
+      codex.sources.every((source) => source.clientIds.includes("codex")),
+    ).toBe(true)
+    expect(
+      codex.sources.some((source) => source.filename === "CLAUDE.md"),
+    ).toBe(false)
+
+    const claude = await resolveAgents({
+      folder: project,
+      client: "claude",
+      homeDir: home,
+    })
+    expect(
+      claude.sources.every((source) => source.clientIds.includes("claude")),
+    ).toBe(true)
+    expect(
+      claude.sources.some((source) => source.filename === "AGENTS.md"),
+    ).toBe(false)
+  })
+
+  test("deduplicates physical files and labels every client that loads them", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".codex"), { recursive: true })
+    await mkdir(join(home, ".claude"), { recursive: true })
+    await mkdir(join(home, ".pi", "agent"), { recursive: true })
+    await mkdir(join(home, ".agents"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(repo, "AGENTS.md"), "# repository\n")
+
+    const shared = join(home, "shared", "instructions.md")
+    await mkdir(join(home, "shared"), { recursive: true })
+    await writeFile(shared, "# shared-global\n")
+    await symlink(
+      "../shared/instructions.md",
+      join(home, ".codex", "AGENTS.md"),
+    )
+    await symlink(
+      "../shared/instructions.md",
+      join(home, ".claude", "CLAUDE.md"),
+    )
+    await symlink(
+      "../../shared/instructions.md",
+      join(home, ".pi", "agent", "AGENTS.md"),
+    )
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "all",
+      homeDir: home,
+    })
+
+    const repositorySource = result.sources.find((source) =>
+      source.text.includes("# repository"),
+    )
+    expect(repositorySource.clientIds).toEqual(["generic", "codex", "pi"])
+
+    const sharedReal = await realpath(shared)
+    const sharedGlobal = result.sources.find(
+      (source) => source.path === sharedReal,
+    )
+    expect(sharedGlobal).toBeTruthy()
+    expect(sharedGlobal.filename).toBe("AGENTS.md")
+    expect(sharedGlobal.clientIds).toEqual(["codex", "claude", "pi"])
+    expect(sharedGlobal.sourcePaths).toContain(
+      join(home, ".codex", "AGENTS.md"),
+    )
+    expect(sharedGlobal.sourcePaths).toContain(
+      join(home, ".claude", "CLAUDE.md"),
+    )
+  })
+
+  test("only the current folder chain is inventoried: no sibling or child folders", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    const sibling = join(repo, "sibling")
+    const child = join(project, "child")
+    await mkdir(project, { recursive: true })
+    await mkdir(sibling, { recursive: true })
+    await mkdir(child, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(child, "AGENTS.md"), "# child\n")
+    await writeFile(join(sibling, "AGENTS.md"), "# sibling\n")
+    await writeFile(join(repo, "AGENTS.md"), "# repository\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    const text = result.sources.map((source) => source.text).join("\n")
+    expect(text).toContain("# project")
+    expect(text).toContain("# repository")
+    expect(text).not.toContain("# child")
+    expect(text).not.toContain("# sibling")
+  })
+
+  test("an unreadable file stays visible and is not silently hidden", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# secret-format\n")
+    await chmod(join(project, "AGENTS.md"), 0o000)
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    const source = result.sources[0]
+    expect(source.status).toBe("unreadable")
+    expect(source.text).toBe("")
+    expect(source.reason).toBeTruthy()
+    expect(source.filename).toBe("AGENTS.md")
+  })
+
+  test("a symlink to a non-instruction file is unsafe and not read", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    const secret = join(base, "secret.txt")
+    await writeFile(secret, "# top-secret\n")
+    await symlink(secret, join(project, "AGENTS.md"))
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    const source = result.sources.find(
+      (candidate) => candidate.level === "project",
+    )
+    expect(source.status).toBe("unsafe")
+    expect(source.reason).toContain("non-instruction file")
+    expect(source.text).toBe("")
+  })
+
+  test("a directory at an instruction location is not read", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(join(project, "AGENTS.md"), { recursive: true })
+    await writeFile(join(project, "AGENTS.md", "inside.txt"), "# hidden\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    expect(result.sources.some((source) => source.level === "project")).toBe(
+      false,
+    )
+  })
+
+  test("full instruction text is read without truncation", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    const content = "x".repeat(400 * 1024)
+    await writeFile(join(project, "AGENTS.md"), content)
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+    })
+
+    expect(result.sources[0].text).toBe(content)
+    expect(result.sources[0].size).toBe(content.length)
+  })
+
+  test("CODEX_HOME overrides the Codex global directory", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const codexHome = join(base, "custom-codex")
+    await mkdir(codexHome, { recursive: true })
+    await writeFile(join(codexHome, "AGENTS.md"), "# custom-codex\n")
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    setEnv("CODEX_HOME", codexHome)
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "codex",
+      homeDir: home,
+    })
+
+    const global = result.sources.find((source) => source.level === "global")
+    expect(global.text).toContain("# custom-codex")
+    expect(global.directory).toBe(await realpath(codexHome))
+  })
+
+  test("PI_CODING_AGENT_DIR overrides the Pi global directory", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const piDir = join(base, "custom-pi")
+    await mkdir(piDir, { recursive: true })
+    await writeFile(join(piDir, "AGENTS.md"), "# custom-pi\n")
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    setEnv("PI_CODING_AGENT_DIR", piDir)
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "pi",
+      homeDir: home,
+    })
+
+    const global = result.sources.find((source) => source.level === "global")
+    expect(global.text).toContain("# custom-pi")
+  })
+
+  test("a configured Codex model_instructions_file is reported as unsupported", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const codexHome = join(base, "custom-codex")
+    await mkdir(codexHome, { recursive: true })
+    await writeFile(
+      join(codexHome, "config.toml"),
+      `model_instructions_file = "TEAM.md"\n`,
+    )
+    await writeFile(join(codexHome, "AGENTS.md"), "# codex\n")
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    setEnv("CODEX_HOME", codexHome)
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "codex",
+      homeDir: home,
+    })
+
+    const unsupported = result.warnings.find(
+      (warning) => warning.kind === "unsupported",
+    )
+    expect(unsupported).toBeTruthy()
+    expect(unsupported.reason).toContain("model_instructions_file")
+  })
+
+  test("readText false skips content but reports the source for the navigation count", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(repo, "AGENTS.md"), "# repository\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+      readText: false,
+    })
+
+    expect(result.sources).toHaveLength(2)
+    expect(result.sources.every((source) => source.text === "")).toBe(true)
+    expect(result.sources.every((source) => source.status === "loaded")).toBe(
+      true,
+    )
+  })
+
+  test("linked folders contribute instruction rows after the repository and before global", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(join(home, ".agents"), { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    await writeFile(join(repo, "AGENTS.md"), "# repository\n")
+    await writeFile(join(home, ".agents", "AGENTS.md"), "# global\n")
+    const linked = join(base, "linked-notes")
+    await mkdir(linked, { recursive: true })
+    await writeFile(join(linked, "AGENTS.md"), "# linked folder\n")
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+      linkedFolders: [linked],
+    })
+
+    const linkedPath = await realpath(linked)
+    expect(result.sources.map((source) => source.level)).toEqual([
+      "project",
+      "parent",
+      "linked",
+      "global",
+    ])
+    const linkedSource = result.sources.find(
+      (source) => source.level === "linked",
+    )
+    expect(linkedSource).toMatchObject({
+      directory: linkedPath,
+      filename: "AGENTS.md",
+      path: join(linkedPath, "AGENTS.md"),
+      clientIds: ["generic"],
+    })
+    expect(linkedSource.text).toContain("# linked folder")
+
+    // The linked folder is the final chain row, labelled `linked` (never a
+    // client-loaded ancestor).
+    const linkedIndex = result.chain.findIndex(
+      (entry) => entry.directory === linkedPath,
+    )
+    expect(linkedIndex).toBeGreaterThan(0)
+    expect(result.chain.at(-1)).toMatchObject({
+      directory: linkedPath,
+      level: "linked",
+      filenames: ["AGENTS.md"],
+    })
+  })
+
+  test("a linked folder without instruction files stays listed in the chain but yields no source", async () => {
+    const base = await freshBase()
+    cleanup.push(base)
+    const home = join(base, "home")
+    await mkdir(home, { recursive: true })
+    const repo = await repository(base)
+    const project = join(repo, "project")
+    await mkdir(project, { recursive: true })
+    await writeFile(join(project, "AGENTS.md"), "# project\n")
+    const linked = join(base, "empty-linked")
+    await mkdir(linked, { recursive: true })
+
+    const result = await resolveAgents({
+      folder: project,
+      client: "generic",
+      homeDir: home,
+      linkedFolders: [linked],
+    })
+
+    const linkedPath = await realpath(linked)
+    expect(result.sources.some((source) => source.level === "linked")).toBe(
+      false,
+    )
+    expect(result.chain.some((entry) => entry.directory === linkedPath)).toBe(
+      true,
+    )
+    expect(result.chain.at(-1)).toMatchObject({
+      directory: linkedPath,
+      level: "linked",
+      filenames: [],
+    })
+  })
+})