clank-cli 0.1.67 → 0.1.72

package/README.md

@@ -24,6 +24,7 @@ Clank stores your AI agent files (CLAUDE.md, commands, notes) in a separate git
 - **Multi-Agent Support**: Single source file, multiple symlinks (AGENTS.md, CLAUDE.md, GEMINI.md).
 - **Worktree-Aware**: Works seamlessly with git worktrees.
 - **Git Ignored**: Agent files are ignored in the main repo, tracked in the overlay repo.
+- **Rules Consolidation**: Use `.claude/rules/` for modular instructions; clank auto-generates AGENTS.md/GEMINI.md with consolidated content for cross-agent compatibility.
 - **Three Scopes**: Global (all projects), Project (all branches), Worktree (this branch only).
 
 ## Installation
@@ -300,6 +301,12 @@ Available placeholders:
 - `{{project_name}}` - Project name from git
 - `{{branch_name}}` - Current branch/worktree name
 
+## Rules Consolidation
+
+If you use Claude Code's `.claude/rules/` for modular instructions, clank automatically generates AGENTS.md and GEMINI.md by consolidating `agents.md` with all your rules. Claude reads rules natively via symlinks; other agents get everything in one file.
+
+Store rules in `claude/rules/` in your overlay, then run `clank link`. Consolidation activates automatically when rules files exist -- when there are no rules, all agent files remain symlinks as before.
+
 ## Design Principles
 
 1. **Everything is linked, nothing is copied** - Single source of truth in overlay
@@ -336,7 +343,8 @@ Available placeholders:
         ├── claude/           # Claude Code specific
         │   ├── settings.json # -> .claude/settings.json
         │   ├── commands/     # -> .claude/commands/
-        │   └── agents/       # -> .claude/agents/
+        │   ├── agents/       # -> .claude/agents/
+        │   └── rules/        # -> .claude/rules/ (also consolidated into AGENTS.md/GEMINI.md)
         ├── gemini/           # Gemini specific
         │   └── commands/     # -> .gemini/commands/
         └── worktrees/

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clank-cli",
   "description": "Keep AI files in a separate overlay repository",
-  "version": "0.1.67",
+  "version": "0.1.72",
   "author": "",
   "type": "module",
   "bin": {

package/src/ClassifyFiles.ts

@@ -1,10 +1,12 @@
 import { lstat } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { agentFiles } from "./AgentFiles.ts";
+import { isGeneratedByClank } from "./Consolidate.ts";
 import {
   isTrackedByGit,
   relativePath,
   resolveSymlinkTarget,
+  toSlash,
   walkDirectory,
 } from "./FsUtil.ts";
 import type { GitContext } from "./Git.ts";
@@ -90,11 +92,14 @@ ${commands.join("\n")}`);
   }
 
   if (classified.untracked.length > 0) {
-    const commands = classified.untracked.map((p) => `  clank add ${rel(p)}`);
+    const files = classified.untracked.map((p) => `  ${rel(p)}`);
     sections.push(`Found untracked agent files.
 
 Add them to clank:
-${commands.join("\n")}`);
+${files.join("\n")}
+
+  clank add -i                  # add interactively
+  clank add <file> [<file>...]  # add specific files`);
   }
 
   if (classified.staleSymlinks.length > 0) {
@@ -153,6 +158,7 @@ async function classifySingleAgentFile(
     return classifyAgentSymlink(filePath, overlayRoot, mapperCtx);
   }
   if (stat.isFile()) {
+    if (await isGeneratedByClank(filePath)) return {};
     const isTracked = await isTrackedByGit(filePath, targetRoot);
     return isTracked ? { tracked: [filePath] } : { untracked: [filePath] };
   }
@@ -180,7 +186,7 @@ async function classifyAgentSymlink(
   const absoluteTarget = await resolveSymlinkTarget(filePath);
 
   // Symlink doesn't point to overlay at all
-  if (!absoluteTarget.startsWith(overlayRoot)) {
+  if (!toSlash(absoluteTarget).startsWith(toSlash(overlayRoot))) {
     return { staleSymlinks: [filePath] };
   }
 

package/src/Consolidate.ts

@@ -0,0 +1,250 @@
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { agentFiles, forEachAgentPath } from "./AgentFiles.ts";
+import { fileExists, isSymlink, walkDirectory } from "./FsUtil.ts";
+import type { GitContext } from "./Git.ts";
+import { overlayProjectDir, overlayWorktreeDir } from "./Mapper.ts";
+
+/** Params for the consolidation entry point */
+export interface ConsolidateParams {
+  overlayRoot: string;
+  targetRoot: string;
+  gitContext: GitContext;
+  agents: string[];
+}
+
+/** A rules file with its parsed metadata and content */
+interface RuleFile {
+  filename: string;
+  content: string;
+  description?: string;
+  paths?: string;
+}
+
+/** First-line marker for generated agent files */
+export const generatedMarker = "<!-- Generated by clank";
+
+/**
+ * Consolidate agents.md + .claude/rules/ into generated AGENTS.md/GEMINI.md.
+ *
+ * Only runs when rules files exist in the overlay. Root-level only --
+ * subdirectory agents.md files continue as pure symlinks.
+ */
+export async function consolidateRulesIntoAgentFiles(
+  params: ConsolidateParams,
+): Promise<string[]> {
+  const { overlayRoot, targetRoot, gitContext, agents } = params;
+
+  // Collect rules from all applicable overlay scopes
+  const rulesFiles = await collectRulesFiles(overlayRoot, gitContext);
+  if (rulesFiles.length === 0) return [];
+
+  // Read root-level agents.md from overlay (if exists)
+  const agentsMdContent = await readRootAgentsMd(overlayRoot, gitContext);
+
+  // Build the consolidated content
+  const overlayPaths = getOverlayPaths(overlayRoot, gitContext);
+  const merged = buildConsolidatedContent(
+    agentsMdContent,
+    rulesFiles,
+    overlayPaths,
+  );
+
+  // For each non-claude agent, replace the symlink with a generated file
+  const generated: string[] = [];
+  await forEachAgentPath(targetRoot, agents, async (agentPath, agentName) => {
+    if (agentName.toLowerCase() === "claude") return;
+    // Remove existing symlink if present
+    if (await isSymlink(agentPath)) {
+      await unlink(agentPath);
+    }
+    await writeFile(agentPath, merged, "utf-8");
+    generated.push(basename(agentPath));
+  });
+
+  return generated;
+}
+
+/** Check if a file is generated by clank (first line starts with marker) */
+export async function isGeneratedByClank(filePath: string): Promise<boolean> {
+  if (!(await fileExists(filePath))) return false;
+  if (await isSymlink(filePath)) return false;
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return content.startsWith(generatedMarker);
+  } catch {
+    return false;
+  }
+}
+
+/** Strip YAML frontmatter and extract description/paths */
+export function stripFrontmatter(raw: string): {
+  content: string;
+  description?: string;
+  paths?: string;
+} {
+  const fence = "---";
+  const fenceNewline = `\n${fence}`;
+
+  if (!raw.startsWith(fence)) {
+    return { content: raw };
+  }
+
+  const endIndex = raw.indexOf(fenceNewline, fence.length);
+  if (endIndex === -1) {
+    return { content: raw };
+  }
+
+  const frontmatter = raw.slice(fence.length, endIndex).trim();
+  const content = raw.slice(endIndex + fenceNewline.length).replace(/^\n+/, "");
+
+  let description: string | undefined;
+  let paths: string | undefined;
+
+  for (const line of frontmatter.split("\n")) {
+    const descMatch = line.match(/^description:\s*(.+)/);
+    if (descMatch) {
+      description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    const pathsMatch = line.match(/^paths:\s*(.+)/);
+    if (pathsMatch) {
+      // paths can be inline array: ["src/**/*.ts"] or plain string
+      paths = pathsMatch[1]
+        .trim()
+        .replace(/^\[|\]$/g, "")
+        .replace(/["']/g, "");
+    }
+  }
+
+  return { content, description, paths };
+}
+
+/** Convert a filename to a human-readable heading */
+export function humanizeFilename(filename: string): string {
+  return filename.replace(/\.md$/, "").replace(/[-_]/g, " ");
+}
+
+/** Remove generated agent files from target (for unlink) */
+export async function removeGeneratedAgentFiles(
+  targetRoot: string,
+): Promise<string[]> {
+  const removed: string[] = [];
+  for (const name of agentFiles) {
+    const path = join(targetRoot, name);
+    if (await isGeneratedByClank(path)) {
+      await unlink(path);
+      removed.push(name);
+    }
+  }
+  return removed;
+}
+
+/** Collect all .md files from claude/rules/ across overlay scopes */
+async function collectRulesFiles(
+  overlayRoot: string,
+  gitContext: GitContext,
+): Promise<RuleFile[]> {
+  const dirs = [
+    join(overlayRoot, "global/claude/rules"),
+    join(
+      overlayProjectDir(overlayRoot, gitContext.projectName),
+      "claude/rules",
+    ),
+    join(overlayWorktreeDir(overlayRoot, gitContext), "claude/rules"),
+  ];
+
+  const allFiles: RuleFile[] = [];
+  for (const dir of dirs) {
+    if (!(await fileExists(dir))) continue;
+    for await (const { path, isDirectory } of walkDirectory(dir)) {
+      if (isDirectory) continue;
+      if (!path.endsWith(".md")) continue;
+      const raw = await readFile(path, "utf-8");
+      const parsed = stripFrontmatter(raw);
+      allFiles.push({
+        filename: basename(path),
+        ...parsed,
+      });
+    }
+  }
+
+  // Sort alphabetically by filename for deterministic output
+  allFiles.sort((a, b) => a.filename.localeCompare(b.filename));
+  return allFiles;
+}
+
+/** Read root-level agents.md from the overlay (project scope, then global) */
+async function readRootAgentsMd(
+  overlayRoot: string,
+  gitContext: GitContext,
+): Promise<string | null> {
+  const projectPath = join(
+    overlayProjectDir(overlayRoot, gitContext.projectName),
+    "agents.md",
+  );
+  if (await fileExists(projectPath)) {
+    return readFile(projectPath, "utf-8");
+  }
+
+  // Fall back to global agents.md
+  const globalPath = join(overlayRoot, "global/agents.md");
+  if (await fileExists(globalPath)) {
+    return readFile(globalPath, "utf-8");
+  }
+
+  return null;
+}
+
+/** Get overlay paths for the header comments */
+function getOverlayPaths(
+  overlayRoot: string,
+  gitContext: GitContext,
+): { agentsMdPath: string; rulesDir: string } {
+  const projectDir = overlayProjectDir(overlayRoot, gitContext.projectName);
+  return {
+    agentsMdPath: join(projectDir, "agents.md"),
+    rulesDir: join(projectDir, "claude/rules"),
+  };
+}
+
+/** Build the consolidated markdown content */
+function buildConsolidatedContent(
+  agentsMdContent: string | null,
+  rules: RuleFile[],
+  overlayPaths: { agentsMdPath: string; rulesDir: string },
+): string {
+  const lines: string[] = [];
+
+  // Header comments
+  lines.push(`${generatedMarker} - do not edit -->`);
+  if (agentsMdContent) {
+    lines.push(`<!-- Source: ${overlayPaths.agentsMdPath} -->`);
+  }
+  lines.push(`<!-- Rules: ${overlayPaths.rulesDir} -->`);
+  lines.push("");
+
+  // Base agents.md content
+  if (agentsMdContent) {
+    lines.push(agentsMdContent.trimEnd());
+  }
+
+  // Append each rule as a section
+  for (const rule of rules) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+
+    const heading = rule.description || humanizeFilename(rule.filename);
+    lines.push(`## ${heading}`);
+
+    if (rule.paths) {
+      lines.push(`Applies to: ${rule.paths}`);
+    }
+
+    lines.push("");
+    lines.push(rule.content.trimEnd());
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}

package/src/FsUtil.ts

@@ -5,6 +5,7 @@ import {
   readdir,
   readFile,
   readlink,
+  realpath,
   symlink,
   unlink,
   writeFile,
@@ -28,6 +29,27 @@ interface WalkContext {
   skip?: (relPath: string, isDirectory: boolean) => boolean;
 }
 
+/** Normalize path separators to forward slashes (for cross-platform string comparisons) */
+export function toSlash(p: string): string {
+  return p.replaceAll("\\", "/");
+}
+
+/** Resolve Windows 8.3 short names to canonical long paths.
+ *  On non-Windows, returns the path unchanged. */
+export async function resolveWindowsPath(p: string): Promise<string> {
+  if (process.platform !== "win32") return p;
+  try {
+    return await realpath(p);
+  } catch {
+    return p;
+  }
+}
+
+/** Get the current working directory, resolving Windows 8.3 short names */
+export async function getCwd(): Promise<string> {
+  return resolveWindowsPath(process.cwd());
+}
+
 /**
  * Create a symbolic link, removing existing link/file first
  * @param target - The path the symlink should point to (absolute)
@@ -45,7 +67,24 @@ export async function createSymlink(
     // File doesn't exist, which is fine
   }
 
-  await symlink(target, linkPath);
+  try {
+    await symlink(target, linkPath);
+  } catch (error: unknown) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      error.code === "EPERM" &&
+      process.platform === "win32"
+    ) {
+      throw new Error(
+        `Permission denied creating symlink.\n` +
+          `On Windows, symlinks require Developer Mode or administrator privileges.\n` +
+          `Enable Developer Mode: Settings > Update & Security > For Developers\n` +
+          `Or use clank from WSL.`,
+      );
+    }
+    throw error;
+  }
 }
 
 /** Remove a symlink if it exists */
@@ -62,12 +101,13 @@ export async function removeSymlink(linkPath: string): Promise<void> {
 
 /**
  * Get the symlink target path (absolute)
+ * Uses forward slashes so readlink returns consistent paths across platforms.
  * @param _from - The location of the symlink (unused, kept for API compatibility)
  * @param to - The target of the symlink (absolute)
  * @returns Absolute path to the target
  */
 export function getLinkTarget(_from: string, to: string): string {
-  return to;
+  return toSlash(to);
 }
 
 /** Recursively walk a directory, yielding all files and directories */
@@ -118,7 +158,7 @@ export async function isTrackedByGit(
   repoRoot: string,
 ): Promise<boolean> {
   try {
-    const relPath = relative(repoRoot, filePath);
+    const relPath = toSlash(relative(repoRoot, filePath));
     await execFileAsync("git", ["ls-files", "--error-unmatch", relPath], {
       cwd: repoRoot,
     });
@@ -195,7 +235,7 @@ function* processEntry(
   | { recurse: string; options: WalkOptions; root: string }
 > {
   const fullPath = join(dir, entry.name);
-  const relPath = relative(ctx.root, fullPath);
+  const relPath = toSlash(relative(ctx.root, fullPath));
 
   if (entry.isDirectory()) {
     if (shouldSkipDir(entry.name, ctx.skipDirs, ctx.includeHidden)) return;

package/src/Git.ts

@@ -1,5 +1,6 @@
 import { basename, isAbsolute, join } from "node:path";
 import { exec } from "./Exec.ts";
+import { resolveWindowsPath } from "./FsUtil.ts";
 
 /** Selected git project/worktree metadata */
 export interface GitContext {
@@ -34,7 +35,9 @@ export async function detectGitRoot(
 ): Promise<string> {
   const toplevel = await gitCommand("rev-parse --show-toplevel", cwd);
   if (toplevel) {
-    return toplevel;
+    // On Windows, git returns forward-slash paths that may use long names
+    // while cwd uses 8.3 short names. Resolve to canonical form.
+    return await resolveWindowsPath(toplevel);
   }
   throw new Error("Not in a git repository");
 }
@@ -89,7 +92,7 @@ export async function isGitWorktree(
   }
 
   // Worktrees have .git/worktrees/* in their git-dir path
-  return gitDir.includes("/worktrees/");
+  return gitDir.replaceAll("\\", "/").includes("/worktrees/");
 }
 
 /** Parse repository name from git remote URL (handles HTTPS and SSH formats) */

package/src/Gitignore.ts

@@ -1,8 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { basename, dirname, join, relative } from "node:path";
+import picomatch from "picomatch";
 import { agentFiles, targetManagedDirs } from "./AgentFiles.ts";
 import { filterClankLines } from "./Exclude.ts";
-import { fileExists, walkDirectory } from "./FsUtil.ts";
+import { fileExists, toSlash, walkDirectory } from "./FsUtil.ts";
 import { getGitDir } from "./Git.ts";
 import { partition } from "./Util.ts";
 
@@ -52,7 +53,7 @@ export async function collectGitignorePatterns(
 
   // 3. Find nested .gitignore files
   for (const path of await findNestedGitignores(targetRoot)) {
-    const basePath = relative(targetRoot, dirname(path));
+    const basePath = toSlash(relative(targetRoot, dirname(path)));
     await parseGitignoreFile(path, result, { basePath });
   }
 
@@ -144,6 +145,23 @@ export function deduplicateGlobs(globs: string[]): string[] {
   return [...universal, ...uncovered];
 }
 
+/** Load a repo's .gitignore and return a matcher for ignored filenames */
+export async function loadGitignore(
+  repoRoot: string,
+): Promise<(name: string) => boolean> {
+  const gitignorePath = join(repoRoot, ".gitignore");
+  if (!(await fileExists(gitignorePath))) return () => false;
+
+  const content = await readFile(gitignorePath, "utf-8");
+  const patterns = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
+
+  if (patterns.length === 0) return () => false;
+  return picomatch(patterns);
+}
+
 /** Parse a gitignore file and accumulate results */
 async function parseGitignoreFile(
   source: string,

package/src/Mapper.ts

@@ -1,5 +1,6 @@
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
 import { managedAgentDirs } from "./AgentFiles.ts";
+import { toSlash } from "./FsUtil.ts";
 import type { GitContext } from "./Git.ts";
 
 /** overlay mappings can be cross project, per project, or per worktree */
@@ -83,14 +84,17 @@ export function overlayToTarget(
   context: MapperContext,
 ): TargetMapping | null {
   const { overlayRoot, targetRoot, gitContext } = context;
-  const projectPrefix = join(overlayRoot, "targets", gitContext.projectName);
-  const globalPrefix = join(overlayRoot, "global");
+  const op = toSlash(overlayPath);
+  const projectPrefix = toSlash(
+    join(overlayRoot, "targets", gitContext.projectName),
+  );
+  const globalPrefix = toSlash(join(overlayRoot, "global"));
 
-  if (overlayPath.startsWith(globalPrefix)) {
+  if (op.startsWith(globalPrefix)) {
     return mapGlobalOverlay(overlayPath, globalPrefix, targetRoot);
   }
 
-  if (overlayPath.startsWith(projectPrefix)) {
+  if (op.startsWith(projectPrefix)) {
     return mapProjectOverlay(overlayPath, projectPrefix, context);
   }
 
@@ -118,7 +122,7 @@ export function targetToOverlay(
   context: MapperContext,
 ): string {
   const { overlayRoot, targetRoot, gitContext } = context;
-  const relPath = relative(targetRoot, targetPath);
+  const relPath = toSlash(relative(targetRoot, targetPath));
 
   let overlayBase: string;
   if (scope === "global") {
@@ -145,7 +149,14 @@ export function normalizeAddPath(
   cwd: string,
   gitRoot: string,
 ): string {
-  const normalized = input.replace(/^\.\//, "");
+  // Normalize separators: strip leading ./ or .\ then use forward slashes
+  // for consistent string matching (path.join handles both on Windows)
+  const normalized = input.replace(/^\.[\\/]/, "").replaceAll("\\", "/");
+
+  // Absolute paths are already resolved — just handle agent file aliasing
+  if (isAbsolute(input)) {
+    return isAgentFile(normalized) ? join(dirname(input), "agents.md") : input;
+  }
 
   // Treat agent files (CLAUDE.md, GEMINI.md) as aliases for agents.md
   // Support both relative paths (packages/foo/CLAUDE.md) and running from subdirectory
@@ -156,19 +167,14 @@ export function normalizeAddPath(
   }
 
   // .claude/ and .gemini/ files keep their path (relative to git root)
-  for (const agentDir of managedAgentDirs) {
-    if (normalized.startsWith(`${agentDir}/`)) {
-      return join(gitRoot, normalized);
-    }
+  if (startsWithAgentDir(normalized)) {
+    return join(gitRoot, normalized);
   }
 
   // If cwd is inside a .claude/ or .gemini/ directory, join directly
   // (e.g., running `clank rm foo.md` from .claude/commands/)
-  const relCwd = relative(gitRoot, cwd);
-  for (const agentDir of managedAgentDirs) {
-    if (relCwd.startsWith(`${agentDir}/`) || relCwd === agentDir) {
-      return join(cwd, normalized);
-    }
+  if (isInsideAgentDir(toSlash(relative(gitRoot, cwd)))) {
+    return join(cwd, normalized);
   }
 
   // If path already contains /clank/ in the middle, preserve its structure
@@ -183,7 +189,7 @@ export function normalizeAddPath(
 
   // Strip trailing /clank from cwd to avoid clank/clank nesting
   // But don't strip if we're at the git root (project might be named "clank")
-  const inClankSubdir = cwd.endsWith("/clank") && cwd !== gitRoot;
+  const inClankSubdir = toSlash(cwd).endsWith("/clank") && cwd !== gitRoot;
   const normalizedCwd = inClankSubdir ? cwd.slice(0, -"/clank".length) : cwd;
 
   return join(normalizedCwd, "clank", filename);
@@ -202,8 +208,9 @@ export function isAgentFile(filename: string): boolean {
 
 /** Check if a path is a prompt file in an agent's prompts directory */
 export function isPromptFile(normalizedPath: string): boolean {
+  const p = toSlash(normalizedPath);
   for (const agentDir of managedAgentDirs) {
-    if (normalizedPath.includes(`/${agentDir}/prompts/`)) {
+    if (p.includes(`/${agentDir}/prompts/`)) {
       return true;
     }
   }
@@ -212,11 +219,12 @@ export function isPromptFile(normalizedPath: string): boolean {
 
 /** Extract the prompt-relative path from a full prompt path */
 export function getPromptRelPath(normalizedPath: string): string | null {
+  const p = toSlash(normalizedPath);
   for (const agentDir of managedAgentDirs) {
     const marker = `/${agentDir}/prompts/`;
-    const idx = normalizedPath.indexOf(marker);
+    const idx = p.indexOf(marker);
     if (idx !== -1) {
-      return normalizedPath.slice(idx + marker.length);
+      return p.slice(idx + marker.length);
     }
   }
   return null;
@@ -240,7 +248,7 @@ function mapGlobalOverlay(
   globalPrefix: string,
   targetRoot: string,
 ): TargetMapping | null {
-  const relPath = relative(globalPrefix, overlayPath);
+  const relPath = toSlash(relative(globalPrefix, overlayPath));
 
   // Skip init templates
   if (relPath.startsWith("init/")) return null;
@@ -255,12 +263,12 @@ function mapProjectOverlay(
   context: MapperContext,
 ): TargetMapping | null {
   const { targetRoot, gitContext } = context;
-  const relPath = relative(projectPrefix, overlayPath);
+  const relPath = toSlash(relative(projectPrefix, overlayPath));
 
   // Worktree-specific files
-  const worktreePrefix = join("worktrees", gitContext.worktreeName);
+  const worktreePrefix = `worktrees/${gitContext.worktreeName}`;
   if (relPath.startsWith(`${worktreePrefix}/`)) {
-    const innerPath = relative(worktreePrefix, relPath);
+    const innerPath = toSlash(relative(worktreePrefix, relPath));
     return decodeOverlayPath(innerPath, targetRoot, "worktree");
   }
 
@@ -306,6 +314,18 @@ function encodeTargetPath(relPath: string, overlayBase: string): string {
   return join(overlayBase, "clank", relPath);
 }
 
+/** Check if path starts with a managed agent dir (.claude/, .gemini/) */
+function startsWithAgentDir(path: string): boolean {
+  return managedAgentDirs.some((dir) => path.startsWith(`${dir}/`));
+}
+
+/** Check if path is inside a managed agent dir (.claude/, .gemini/) */
+function isInsideAgentDir(relPath: string): boolean {
+  return managedAgentDirs.some(
+    (dir) => relPath.startsWith(`${dir}/`) || relPath === dir,
+  );
+}
+
 /** Decode an overlay-relative path to target (shared by all scopes) */
 function decodeOverlayPath(
   relPath: string,

package/src/OverlayLinks.ts

@@ -1,5 +1,5 @@
 import { lstat, unlink } from "node:fs/promises";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import picomatch from "picomatch";
 import { managedAgentDirs, targetManagedDirs } from "./AgentFiles.ts";
 import {
@@ -8,6 +8,7 @@ import {
   getLinkTarget,
   isSymlink,
   resolveSymlinkTarget,
+  toSlash,
   walkDirectory,
 } from "./FsUtil.ts";
 import type { GitContext } from "./Git.ts";
@@ -44,7 +45,7 @@ export async function verifyManaged(
     const absoluteTarget = await resolveSymlinkTarget(linkPath);
 
     // Check if symlink points to overlay at all
-    if (!absoluteTarget.startsWith(overlayRoot)) {
+    if (!toSlash(absoluteTarget).startsWith(toSlash(overlayRoot))) {
       return { kind: "outside-overlay", currentTarget: absoluteTarget };
     }
 
@@ -88,7 +89,7 @@ export async function isSymlinkToOverlay(
     }
 
     const absoluteTarget = await resolveSymlinkTarget(linkPath);
-    return absoluteTarget.startsWith(overlayRoot);
+    return toSlash(absoluteTarget).startsWith(toSlash(overlayRoot));
   } catch {
     return false;
   }
@@ -105,8 +106,7 @@ export async function* walkOverlayFiles(
   const skip = (relPath: string): boolean => {
     if (relPath.startsWith("clank/init/")) return true; // Skip templates
     if (!isIgnored) return false;
-    const basename = relPath.split("/").at(-1) ?? "";
-    return isIgnored(relPath) || isIgnored(basename);
+    return isIgnored(relPath) || isIgnored(basename(relPath));
   };
 
   const genEntries = walkDirectory(overlayRoot, { skip });
@@ -133,15 +133,6 @@ export async function createPromptLinks(
   return created;
 }
 
-/** Check if two paths are equivalent prompt files in different agent directories */
-function isMatchingPromptPath(
-  canonicalPath: string,
-  actualPath: string,
-): boolean {
-  const canonical = getPromptRelPath(canonicalPath);
-  return canonical !== null && canonical === getPromptRelPath(actualPath);
-}
-
 /** Find and remove symlinks pointing to wrong worktree in the overlay.
  *  Returns paths that were removed. */
 export async function cleanStaleWorktreeSymlinks(
@@ -152,16 +143,16 @@ export async function cleanStaleWorktreeSymlinks(
   const removed: string[] = [];
   const currentWorktree = gitContext.worktreeName;
   const projectName = gitContext.projectName;
-  const worktreesPrefix = `${overlayRoot}/targets/${projectName}/worktrees/`;
+  const worktreesPrefix = `${toSlash(overlayRoot)}/targets/${projectName}/worktrees/`;
 
   for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
     if (isDirectory) continue;
 
-    const relPath = relative(targetRoot, path);
+    const relPath = toSlash(relative(targetRoot, path));
     if (!isInManagedDir(relPath)) continue;
     if (!(await isSymlink(path))) continue;
 
-    const target = await resolveSymlinkTarget(path);
+    const target = toSlash(await resolveSymlinkTarget(path));
     if (!target.startsWith(worktreesPrefix)) continue;
 
     // Extract worktree name from path like .../worktrees/main/clank/notes.md
@@ -177,6 +168,15 @@ export async function cleanStaleWorktreeSymlinks(
   return removed;
 }
 
+/** Check if two paths are equivalent prompt files in different agent directories */
+function isMatchingPromptPath(
+  canonicalPath: string,
+  actualPath: string,
+): boolean {
+  const canonical = getPromptRelPath(canonicalPath);
+  return canonical !== null && canonical === getPromptRelPath(actualPath);
+}
+
 /** Check if a path is inside a clank-managed directory */
 function isInManagedDir(relPath: string): boolean {
   const parts = relPath.split("/");

package/src/ScopeFromSymlink.ts

@@ -1,5 +1,5 @@
 import { lstat } from "node:fs/promises";
-import { resolveSymlinkTarget } from "./FsUtil.ts";
+import { resolveSymlinkTarget, toSlash } from "./FsUtil.ts";
 import { type MapperContext, overlayToTarget, type Scope } from "./Mapper.ts";
 
 /** Get scope from symlink target if it points to overlay */
@@ -12,7 +12,8 @@ export async function scopeFromSymlink(
     if (!stats.isSymbolicLink()) return null;
 
     const overlayPath = await resolveSymlinkTarget(targetPath);
-    if (!overlayPath.startsWith(context.overlayRoot)) return null;
+    if (!toSlash(overlayPath).startsWith(toSlash(context.overlayRoot)))
+      return null;
 
     const mapping = overlayToTarget(overlayPath, context);
     return mapping?.scope ?? null;

package/src/commands/Add.ts

@@ -8,11 +8,13 @@ import {
 import { basename, dirname, join, relative } from "node:path";
 import * as readline from "node:readline";
 import { forEachAgentPath } from "../AgentFiles.ts";
+import { classifyAgentFiles } from "../ClassifyFiles.ts";
 import { expandPath, loadConfig, validateOverlayExists } from "../Config.ts";
 import {
   createSymlink,
   ensureDir,
   fileExists,
+  getCwd,
   getLinkTarget,
   isSymlink,
   isTrackedByGit,
@@ -81,7 +83,7 @@ export async function addCommand(
   filePaths: string[],
   options: AddOptions = {},
 ): Promise<void> {
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);
@@ -144,19 +146,34 @@ async function addAllInteractive(ctx: AddContext): Promise<void> {
   const unadded = await findUnaddedFiles(context);
   const regularFiles = unadded.filter((f) => f.kind === "unadded");
 
-  if (regularFiles.length === 0) {
+  // Also find untracked agent files outside managed dirs (e.g. packages/foo/CLAUDE.md)
+  const agentClassification = await classifyAgentFiles(
+    gitContext.gitRoot,
+    overlayRoot,
+    gitContext,
+  );
+  const regularPaths = new Set(regularFiles.map((f) => f.targetPath));
+  const extraAgentPaths = agentClassification.untracked.filter(
+    (p) => !regularPaths.has(p),
+  );
+
+  const allPaths = [
+    ...regularFiles.map((f) => f.targetPath),
+    ...extraAgentPaths,
+  ];
+
+  if (allPaths.length === 0) {
     console.log("No unadded files found.");
     return;
   }
 
-  console.log(`Found ${regularFiles.length} unadded file(s):\n`);
+  console.log(`Found ${allPaths.length} unadded file(s):\n`);
 
   const counts: ScopeCounts = { project: 0, worktree: 0, global: 0, skip: 0 };
 
-  for (let i = 0; i < regularFiles.length; i++) {
-    const file = regularFiles[i];
-    const relPath = relative(cwd, file.targetPath);
-    const result = await promptAndAddFile(relPath, i, regularFiles.length, ctx);
+  for (let i = 0; i < allPaths.length; i++) {
+    const relPath = relative(cwd, allPaths[i]);
+    const result = await promptAndAddFile(relPath, i, allPaths.length, ctx);
     if (result === "quit") break;
     if (result !== "error") counts[result]++;
   }

package/src/commands/Check.ts

@@ -7,8 +7,15 @@ import {
   formatAgentFileProblems,
 } from "../ClassifyFiles.ts";
 import { expandPath, loadConfig } from "../Config.ts";
-import { fileExists, relativePath, walkDirectory } from "../FsUtil.ts";
+import {
+  fileExists,
+  getCwd,
+  relativePath,
+  toSlash,
+  walkDirectory,
+} from "../FsUtil.ts";
 import { type GitContext, getGitContext } from "../Git.ts";
+import { loadGitignore } from "../Gitignore.ts";
 import { type MapperContext, overlayProjectDir } from "../Mapper.ts";
 import { formatStatusLines, getOverlayStatus } from "../OverlayGit.ts";
 import { type ManagedFileState, verifyManaged } from "../OverlayLinks.ts";
@@ -33,7 +40,7 @@ const localOnlyFiles = ["settings.local.json"];
 
 /** Check for orphaned overlay paths that don't match target structure */
 export async function checkCommand(): Promise<void> {
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);
@@ -53,15 +60,17 @@ export async function checkCommand(): Promise<void> {
 export async function findUnaddedFiles(
   context: MapperContext,
 ): Promise<UnaddedFile[]> {
-  const { targetRoot } = context;
+  const { targetRoot, overlayRoot } = context;
   const unadded: UnaddedFile[] = [];
+  const isIgnored = await loadGitignore(overlayRoot);
 
   for await (const { path, isDirectory } of walkDirectory(targetRoot)) {
     if (isDirectory) continue;
 
-    const relPath = relative(targetRoot, path);
+    const relPath = toSlash(relative(targetRoot, path));
     if (!isInManagedDir(relPath)) continue;
     if (isLocalOnlyFile(relPath)) continue;
+    if (isIgnored(basename(relPath))) continue;
 
     const managed = await verifyManaged(path, context);
     if (managed.kind !== "valid") {
@@ -91,7 +100,7 @@ export async function findOrphans(
 
   const skip = (relPath: string): boolean => {
     if (isIgnored) {
-      const pathBasename = relPath.split("/").at(-1) ?? "";
+      const pathBasename = basename(relPath);
       if (isIgnored(relPath) || isIgnored(pathBasename)) return true;
     }
     return false;
@@ -103,7 +112,7 @@ export async function findOrphans(
   })) {
     if (isDirectory) continue;
 
-    const relPath = relative(projectDir, path);
+    const relPath = toSlash(relative(projectDir, path));
 
     // Skip files at project root (agents.md, settings.json)
     if (!relPath.includes("/")) continue;
@@ -277,9 +286,12 @@ function showUnaddedFiles(
       `Found ${regularFiles.length} unadded file(s) in ${targetName}:\n`,
     );
     for (const file of regularFiles) {
-      console.log(`  clank add ${relativePath(cwd, file.targetPath)}`);
+      console.log(`  ${relativePath(cwd, file.targetPath)}`);
     }
     console.log();
+    console.log("  clank add -i                  # add interactively");
+    console.log("  clank add <file> [<file>...]  # add specific files");
+    console.log();
   }
 }
 

package/src/commands/Init.ts

@@ -33,6 +33,7 @@ export async function initCommand(overlayPath?: string): Promise<void> {
   await ensureDir(join(targetPath, "targets"));
 
   await createDefaultTemplates(targetPath);
+  await writeFile(join(targetPath, ".gitignore"), ".DS_Store\n", "utf-8");
 
   await createDefaultConfig(targetPath);
 

package/src/commands/Link.ts

@@ -12,14 +12,17 @@ import {
   loadConfig,
   validateOverlayExists,
 } from "../Config.ts";
+import { consolidateRulesIntoAgentFiles } from "../Consolidate.ts";
 import { addGitExcludes } from "../Exclude.ts";
 import {
   createSymlink,
   ensureDir,
   fileExists,
+  getCwd,
   getLinkTarget,
   isSymlink,
   isTrackedByGit,
+  toSlash,
 } from "../FsUtil.ts";
 import { type GitContext, getGitContext } from "../Git.ts";
 import {
@@ -64,7 +67,7 @@ interface SeparatedMappings {
 
 /** Link overlay repository to target directory */
 export async function linkCommand(targetDir?: string): Promise<void> {
-  const gitContext = await getGitContext(targetDir || process.cwd());
+  const gitContext = await getGitContext(targetDir || (await getCwd()));
   const targetRoot = gitContext.gitRoot;
   console.log(`Linking clank overlay to: ${targetRoot}\n`);
   logGitContext(gitContext);
@@ -73,21 +76,7 @@ export async function linkCommand(targetDir?: string): Promise<void> {
   const overlayRoot = expandPath(config.overlayRepo);
   await validateOverlayExists(overlayRoot);
 
-  // Clean up symlinks pointing to wrong worktree before linking
-  const staleRemoved = await cleanStaleWorktreeSymlinks(
-    targetRoot,
-    overlayRoot,
-    gitContext,
-  );
-  if (staleRemoved.length > 0) {
-    console.log(`\nCleaned ${staleRemoved.length} stale worktree symlink(s):`);
-    for (const path of staleRemoved) {
-      console.log(`  ${path}`);
-    }
-  }
-
-  // Check for problematic agent files before proceeding
-  await checkAgentFiles(targetRoot, overlayRoot);
+  await cleanStaleAndCheck(targetRoot, overlayRoot, gitContext);
 
   await ensureDir(join(overlayRoot, "targets", gitContext.projectName));
   await maybeInitWorktree(overlayRoot, gitContext);
@@ -102,6 +91,8 @@ export async function linkCommand(targetDir?: string): Promise<void> {
   await createAgentLinks(agentsMappings, targetRoot, config.agents);
   await createPromptLinks(promptsMappings, targetRoot);
 
+  await maybeConsolidateRules(overlayRoot, targetRoot, gitContext, config);
+
   await setupProjectSettings(overlayRoot, gitContext, targetRoot);
   await addGitExcludes(targetRoot);
   await maybeGenerateVscodeSettings(config, targetRoot);
@@ -119,15 +110,48 @@ function logGitContext(ctx: GitContext): void {
   console.log(`Branch: ${ctx.worktreeName}${suffix}`);
 }
 
-/** Check for problematic agent files and error if found */
-async function checkAgentFiles(
+/** Clean stale worktree symlinks and check for problematic agent files */
+async function cleanStaleAndCheck(
   targetRoot: string,
   overlayRoot: string,
+  gitContext: GitContext,
 ): Promise<void> {
-  const classification = await classifyAgentFiles(targetRoot, overlayRoot);
+  const staleRemoved = await cleanStaleWorktreeSymlinks(
+    targetRoot,
+    overlayRoot,
+    gitContext,
+  );
+  if (staleRemoved.length > 0) {
+    console.log(`\nCleaned ${staleRemoved.length} stale worktree symlink(s):`);
+    for (const path of staleRemoved) {
+      console.log(`  ${path}`);
+    }
+  }
 
+  const classification = await classifyAgentFiles(targetRoot, overlayRoot);
   if (agentFileProblems(classification)) {
-    throw new Error(formatAgentFileProblems(classification, process.cwd()));
+    throw new Error(formatAgentFileProblems(classification, await getCwd()));
+  }
+}
+
+/** Consolidate rules into generated AGENTS.md/GEMINI.md if rules exist */
+async function maybeConsolidateRules(
+  overlayRoot: string,
+  targetRoot: string,
+  gitContext: GitContext,
+  config: ClankConfig,
+): Promise<void> {
+  const consolidated = await consolidateRulesIntoAgentFiles({
+    overlayRoot,
+    targetRoot,
+    gitContext,
+    agents: config.agents,
+  });
+  if (consolidated.length > 0) {
+    console.log(`\nGenerated consolidated agent files:`);
+    for (const name of consolidated) {
+      console.log(`  ${name}`);
+    }
   }
 }
 
@@ -160,7 +184,7 @@ async function collectMappings(
   const isAgent = ({ targetPath }: FileMapping) =>
     basename(targetPath) === "agents.md";
   const isPrompt = ({ targetPath }: FileMapping) =>
-    targetPath.includes("/.claude/prompts/");
+    toSlash(targetPath).includes("/.claude/prompts/");
 
   const agentsMappings = mappings.filter(isAgent);
   const promptsMappings = mappings.filter((m) => !isAgent(m) && isPrompt(m));
@@ -459,7 +483,7 @@ async function checkMappingParentExists(
   m: FileMapping,
   targetRoot: string,
 ): Promise<FileMapping | null> {
-  const relPath = relative(targetRoot, m.targetPath);
+  const relPath = toSlash(relative(targetRoot, m.targetPath));
   // Subdirectory clank files have /clank/ in the middle of the path
   const clankIndex = relPath.indexOf("/clank/");
   if (clankIndex !== -1) {

package/src/commands/Move.ts

@@ -6,6 +6,7 @@ import {
   createSymlink,
   ensureDir,
   fileExists,
+  getCwd,
   getLinkTarget,
 } from "../FsUtil.ts";
 import { getGitContext } from "../Git.ts";
@@ -37,7 +38,7 @@ export async function moveCommand(
   options: MoveOptions,
 ): Promise<void> {
   const hasScope = options.global || options.project || options.worktree;
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);

package/src/commands/Rm.ts

@@ -2,7 +2,7 @@ import { rm, unlink } from "node:fs/promises";
 import { basename, dirname, relative } from "node:path";
 import { forEachAgentPath } from "../AgentFiles.ts";
 import { expandPath, loadConfig, validateOverlayExists } from "../Config.ts";
-import { fileExists } from "../FsUtil.ts";
+import { fileExists, getCwd } from "../FsUtil.ts";
 import { getGitContext } from "../Git.ts";
 import {
   isAgentFile,
@@ -23,7 +23,7 @@ export async function rmCommand(
   filePaths: string[],
   options: RmOptions = {},
 ): Promise<void> {
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const config = await loadConfig();
   const overlayRoot = expandPath(config.overlayRepo);

package/src/commands/Unlink.ts

@@ -1,13 +1,14 @@
 import { expandPath, loadConfig } from "../Config.ts";
+import { removeGeneratedAgentFiles } from "../Consolidate.ts";
 import { removeGitExcludes } from "../Exclude.ts";
-import { fileExists, removeSymlink, walkDirectory } from "../FsUtil.ts";
+import { fileExists, getCwd, removeSymlink, walkDirectory } from "../FsUtil.ts";
 import { getGitContext } from "../Git.ts";
 import { isSymlinkToOverlay } from "../OverlayLinks.ts";
 import { removeVscodeSettings } from "./VsCode.ts";
 
 /** Remove all symlinks pointing to overlay repository */
 export async function unlinkCommand(targetDir?: string): Promise<void> {
-  const gitContext = await getGitContext(targetDir || process.cwd());
+  const gitContext = await getGitContext(targetDir || (await getCwd()));
   const targetRoot = gitContext.gitRoot;
 
   console.log(`Removing clank symlinks from: ${targetRoot}\n`);
@@ -34,6 +35,10 @@ export async function unlinkCommand(targetDir?: string): Promise<void> {
     }
   }
 
+  // Remove generated agent files (from rules consolidation)
+  const generatedRemoved = await removeGeneratedAgentFiles(targetRoot);
+  removedCount += generatedRemoved.length;
+
   await removeGitExcludes(targetRoot);
   await removeVscodeSettings(targetRoot);
 

package/src/commands/VsCode.ts

@@ -5,6 +5,7 @@ import { addToGitExclude } from "../Exclude.ts";
 import {
   ensureDir,
   fileExists,
+  getCwd,
   isTrackedByGit,
   writeJsonFile,
 } from "../FsUtil.ts";
@@ -109,7 +110,7 @@ export async function checkVscodeTracking(
 
 /** Generate VS Code settings to show clank files in search and explorer */
 export async function vscodeCommand(options?: VscodeOptions): Promise<void> {
-  const targetRoot = await detectGitRoot(process.cwd());
+  const targetRoot = await detectGitRoot(await getCwd());
 
   if (options?.remove) {
     await removeVscodeSettings(targetRoot);

package/src/commands/files/Dedupe.ts

@@ -1,4 +1,4 @@
-import { dirname } from "node:path";
+import { basename, dirname } from "node:path";
 import { agentFiles } from "../../AgentFiles.ts";
 import { getPromptRelPath } from "../../Mapper.ts";
 import { partition } from "../../Util.ts";
@@ -15,9 +15,9 @@ export function dedupeEntries(
 
 /** Check if a relative path ends with an agent filename (CLAUDE.md, etc.) */
 export function isAgentFilePath(relPath: string): boolean {
-  const base = relPath.split("/").at(-1)?.toLowerCase();
-  if (!base) return false;
-  return agentFiles.some((f) => f.toLowerCase() === base);
+  return agentFiles.some(
+    (f) => f.toLowerCase() === basename(relPath).toLowerCase(),
+  );
 }
 
 /** Keep at most one agent file per directory, using the configured preference order. */
@@ -129,6 +129,5 @@ function mapPreference(
 }
 
 function basenameUpper(relPath: string): string {
-  const base = relPath.split("/").at(-1) ?? "";
-  return base.toUpperCase();
+  return basename(relPath).toUpperCase();
 }

package/src/commands/files/Scan.ts

@@ -1,6 +1,11 @@
 import { join, relative } from "node:path";
 import { expandPath, loadConfig } from "../../Config.ts";
-import { resolveSymlinkTarget, walkDirectory } from "../../FsUtil.ts";
+import {
+  getCwd,
+  resolveSymlinkTarget,
+  toSlash,
+  walkDirectory,
+} from "../../FsUtil.ts";
 import { getGitContext } from "../../Git.ts";
 import { isClankPath } from "../../Mapper.ts";
 import { isAgentFilePath } from "./Dedupe.ts";
@@ -76,7 +81,7 @@ interface NotLinkedToOverlay {
 export async function getFilesContext(
   inputPath?: string,
 ): Promise<FilesContext> {
-  const cwd = process.cwd();
+  const cwd = await getCwd();
   const gitContext = await getGitContext(cwd);
   const targetRoot = gitContext.gitRoot;
   const scanRoot = resolveScanRoot(targetRoot, cwd, inputPath);
@@ -146,7 +151,7 @@ function resolveScanRoot(
 ): string {
   if (!input) return targetRoot;
   const resolved = join(cwd, input);
-  const rel = normalizeRelPath(relative(targetRoot, resolved));
+  const rel = toSlash(relative(targetRoot, resolved));
   if (rel.startsWith("..")) {
     throw new Error(`Path is outside the git repository: ${input}`);
   }
@@ -178,7 +183,7 @@ async function maybeCreateEntry(
   opts: NormalizedFilesOptions,
   filePath: string,
 ): Promise<FileEntry | null> {
-  const targetRel = normalizeRelPath(relative(ctx.targetRoot, filePath));
+  const targetRel = toSlash(relative(ctx.targetRoot, filePath));
   if (!isManagedTargetPath(targetRel, opts.hidden)) return null;
   if (!passesDepthFilter(targetRel, opts.depth)) return null;
 
@@ -187,16 +192,12 @@ async function maybeCreateEntry(
 
   return {
     absolutePath: filePath,
-    cwdRelativePath: normalizeRelPath(relative(ctx.cwd, filePath) || "."),
+    cwdRelativePath: toSlash(relative(ctx.cwd, filePath) || "."),
     targetRelativePath: targetRel,
     link,
   };
 }
 
-function normalizeRelPath(p: string): string {
-  return p.replaceAll("\\", "/");
-}
-
 /** Decide whether a target-relative path is managed by clank for listing. */
 function isManagedTargetPath(relPath: string, includeHidden: boolean): boolean {
   if (isAgentFilePath(relPath)) return true;
@@ -220,7 +221,8 @@ async function classifyLink(
 ): Promise<LinkState> {
   try {
     const overlayPath = await resolveSymlinkTarget(filePath);
-    if (!overlayPath.startsWith(overlayRoot)) return { kind: "unlinked" };
+    if (!toSlash(overlayPath).startsWith(toSlash(overlayRoot)))
+      return { kind: "unlinked" };
     const scope = inferScopeFromOverlay(overlayPath, overlayRoot, gitContext);
     if (!scope) return { kind: "unlinked" };
     return { kind: "linked", overlayPath, scope };
@@ -263,16 +265,16 @@ function inferScopeFromOverlay(
   overlayRoot: string,
   gitContext: Awaited<ReturnType<typeof getGitContext>>,
 ): "global" | "project" | "worktree" | null {
-  const globalPrefix = `${join(overlayRoot, "global")}/`;
-  if (overlayPath.startsWith(globalPrefix)) return "global";
+  const op = toSlash(overlayPath);
+  const globalPrefix = `${toSlash(join(overlayRoot, "global"))}/`;
+  if (op.startsWith(globalPrefix)) return "global";
 
   const { projectName, worktreeName } = gitContext;
-  const projectPath = join(overlayRoot, "targets", projectName);
-  const worktreePath = join(projectPath, "worktrees", worktreeName);
-  if (overlayPath.startsWith(`${worktreePath}/`)) return "worktree";
+  const projectBase = toSlash(join(overlayRoot, "targets", projectName));
+  const worktreePrefix = `${projectBase}/worktrees/${worktreeName}/`;
+  if (op.startsWith(worktreePrefix)) return "worktree";
 
-  const projectPrefix = `${projectPath}/`;
-  if (overlayPath.startsWith(projectPrefix)) return "project";
+  if (op.startsWith(`${projectBase}/`)) return "project";
 
   return null;
 }