@hurst05/dotagents 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ian Nuttall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+<div align="center">
+  <strong>dotagents</strong>
+  <br />
+  <em>One canonical .agents folder that powers all your AI tools.</em>
+
+  <br /><br />
+  <em>
+    Simple setup • One source of truth • Safe to re-run anytime
+  </em>
+</div>
+
+## Quick Start
+
+Requirements: Node.js 18+ and npm.
+
+Run the guided CLI:
+```bash
+npx @hurst05/dotagents
+```
+
+Choose a workspace (Global home or Project folder), select the clients you want to manage, and follow the prompts. You can run it again anytime to repair links or undo changes.
+
+Global home affects all projects. Project folder only affects the current directory you run dotagents from.
+
+## What it does
+
+- Keeps `.agents` as the source of truth.
+- Creates symlinks for Claude, Codex, Factory, Cursor, OpenCode, and Gemini (based on your selection).
+- Always creates a backup before any overwrite so changes are reversible.
+
+## Where it links (global scope)
+
+`.agents/CLAUDE.md` → `~/.claude/CLAUDE.md` (if present)
+
+`.agents/AGENTS.md` → `~/.claude/CLAUDE.md` (fallback when no CLAUDE.md)
+
+`.agents/GEMINI.md` → `~/.gemini/GEMINI.md` (if present)
+
+`.agents/AGENTS.md` → `~/.gemini/GEMINI.md` (fallback when no GEMINI.md)
+
+`.agents/commands` → `~/.claude/commands`
+
+`.agents/commands` → `~/.factory/commands`
+
+`.agents/commands` → `~/.cursor/commands`
+
+`.agents/commands` → `~/.config/opencode/commands`
+
+`.agents/commands` → `~/.gemini/commands`
+
+`.agents/hooks` → `~/.claude/hooks`
+
+`.agents/hooks` → `~/.factory/hooks`
+
+`.agents/AGENTS.md` → `~/.factory/AGENTS.md`
+
+`.agents/AGENTS.md` → `~/.codex/AGENTS.md`
+
+`.agents/AGENTS.md` → `~/.config/opencode/AGENTS.md`
+
+`.agents/skills` → `~/.claude/skills`
+
+`.agents/skills` → `~/.factory/skills`
+
+`.agents/skills` → `~/.gemini/config/skills` (Antigravity global scope)
+
+Project scope links only commands/hooks/skills into the project’s client folders (no AGENTS/CLAUDE/GEMINI rules).
+
+## Development
+
+Run the CLI in dev mode:
+```bash
+npm run dev
+```
+
+Type-check:
+```bash
+npm run type-check
+```
+
+Run tests:
+```bash
+npm test
+```
+
+Build the CLI:
+```bash
+npm run build
+```
+
+Install dependencies with `npm install`. To use an unpublished local checkout
+from other project folders, run `npm run build && npm link` here, then run
+`dotagents` from the target project.
+
+To publish a public scoped release, sign in with `npm login`, update the version,
+then run `npm publish --access public`. The publish hook runs tests, type-checking,
+and the production build automatically.
+
+## Notes
+
+- Cursor reads `.agents/skills` natively at both user and project scope. dotagents only links `.agents/commands` → `.cursor/commands`.
+- OpenCode uses `~/.config/opencode/AGENTS.md` and prefers AGENTS.md over CLAUDE.md when both exist.
+- Codex custom prompts are deprecated, so dotagents no longer creates `.codex/prompts` links. Existing prompts are still scanned during migration.
+- Codex, Gemini CLI, OpenCode, and GitHub Copilot discover project-level `.agents/skills` natively, so dotagents does not create redundant project links for them.
+- Google Antigravity uses `.agents/skills` inside an active workspace, but global skills live in `~/.gemini/config/skills`; global scope links that folder to the canonical `~/.agents/skills`.
+- Skills require a valid `SKILL.md` with `name` + `description` frontmatter.
+- Claude prompt precedence: if `.agents/CLAUDE.md` exists, it links to `.claude/CLAUDE.md`. Otherwise `.agents/AGENTS.md` is used. After adding or removing `.agents/CLAUDE.md`, re-run dotagents and apply/repair links to update the symlink. Factory/Codex always link to `.agents/AGENTS.md`.
+- Gemini context file precedence: if `.agents/GEMINI.md` exists, it links to `.gemini/GEMINI.md`. Otherwise `.agents/AGENTS.md` is used. After adding or removing `.agents/GEMINI.md`, re-run dotagents and apply/repair links to update the symlink.
+- Project scope creates `.agents` plus client folders for commands/hooks/skills only. Rule files (`AGENTS.md`/`CLAUDE.md`/`GEMINI.md`) are left to the repo root so you can manage them explicitly.
+- Backups are stored under `.agents/backup/<timestamp>` and can be restored via “Undo last change.”
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,1171 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import path13 from "path";
+import chalk from "chalk";
+import { intro, outro, select, confirm, note, spinner, isCancel, cancel, multiselect } from "@clack/prompts";
+
+// src/core/plan.ts
+import fs2 from "fs";
+import path5 from "path";
+
+// src/core/mappings.ts
+import path3 from "path";
+
+// src/core/paths.ts
+import os from "os";
+import path from "path";
+function resolveRoots(opts) {
+  const homeDir = opts.homeDir || os.homedir();
+  const projectRoot = path.resolve(opts.projectRoot || process.cwd());
+  if (opts.scope === "global") {
+    return {
+      canonicalRoot: path.join(homeDir, ".agents"),
+      claudeRoot: path.join(homeDir, ".claude"),
+      factoryRoot: path.join(homeDir, ".factory"),
+      codexRoot: path.join(homeDir, ".codex"),
+      cursorRoot: path.join(homeDir, ".cursor"),
+      opencodeRoot: path.join(homeDir, ".config", "opencode"),
+      opencodeConfigRoot: path.join(homeDir, ".config", "opencode"),
+      geminiRoot: path.join(homeDir, ".gemini"),
+      githubRoot: path.join(projectRoot, ".github"),
+      copilotRoot: path.join(homeDir, ".copilot"),
+      ampcodeConfigRoot: path.join(homeDir, ".config", "amp"),
+      projectRoot,
+      homeDir
+    };
+  }
+  return {
+    canonicalRoot: path.join(projectRoot, ".agents"),
+    claudeRoot: path.join(projectRoot, ".claude"),
+    factoryRoot: path.join(projectRoot, ".factory"),
+    codexRoot: path.join(projectRoot, ".codex"),
+    cursorRoot: path.join(projectRoot, ".cursor"),
+    opencodeRoot: path.join(projectRoot, ".opencode"),
+    opencodeConfigRoot: path.join(homeDir, ".config", "opencode"),
+    geminiRoot: path.join(projectRoot, ".gemini"),
+    githubRoot: path.join(projectRoot, ".github"),
+    copilotRoot: path.join(homeDir, ".copilot"),
+    ampcodeConfigRoot: path.join(homeDir, ".config", "amp"),
+    projectRoot,
+    homeDir
+  };
+}
+
+// src/utils/fs.ts
+import fs from "fs";
+import path2 from "path";
+async function pathExists(p) {
+  try {
+    await fs.promises.lstat(p);
+    return true;
+  } catch (err) {
+    if (err && err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fs.promises.mkdir(dir, { recursive: true });
+}
+async function ensureFile(filePath, content) {
+  await ensureDir(path2.dirname(filePath));
+  await fs.promises.writeFile(filePath, content, "utf8");
+}
+async function readText(filePath) {
+  return await fs.promises.readFile(filePath, "utf8");
+}
+async function copyFile(src, dest, force = false) {
+  if (!force && await pathExists(dest)) return "skipped";
+  await ensureDir(path2.dirname(dest));
+  await fs.promises.copyFile(src, dest);
+  return "written";
+}
+async function copyDir(src, dest, force = false) {
+  if (!force && await pathExists(dest)) return "skipped";
+  await ensureDir(path2.dirname(dest));
+  await fs.promises.cp(src, dest, { recursive: true, force });
+  return "written";
+}
+async function removePath(target) {
+  if (!await pathExists(target)) return;
+  const stat = await fs.promises.lstat(target);
+  if (stat.isDirectory() && !stat.isSymbolicLink()) {
+    await fs.promises.rm(target, { recursive: true, force: true });
+  } else {
+    await fs.promises.unlink(target);
+  }
+}
+async function listDirs(dir) {
+  try {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => path2.join(dir, e.name));
+  } catch (err) {
+    if (err && err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// src/core/mappings.ts
+async function getMappings(opts) {
+  const roots = resolveRoots(opts);
+  const canonical = roots.canonicalRoot;
+  const claudeOverride = path3.join(canonical, "CLAUDE.md");
+  const geminiOverride = path3.join(canonical, "GEMINI.md");
+  const agentsFallback = path3.join(canonical, "AGENTS.md");
+  const claudeSource = await pathExists(claudeOverride) ? claudeOverride : agentsFallback;
+  const geminiSource = await pathExists(geminiOverride) ? geminiOverride : agentsFallback;
+  const clients = new Set(opts.clients ?? ["claude", "factory", "codex", "cursor", "opencode", "gemini", "github", "ampcode"]);
+  const mappings = [];
+  const includeAgentFiles = opts.scope === "global";
+  if (includeAgentFiles && clients.has("claude")) {
+    mappings.push({
+      name: "claude-md",
+      source: claudeSource,
+      targets: [path3.join(roots.claudeRoot, "CLAUDE.md")],
+      kind: "file"
+    });
+  }
+  if (includeAgentFiles && clients.has("gemini")) {
+    mappings.push({
+      name: "gemini-md",
+      source: geminiSource,
+      targets: [path3.join(roots.geminiRoot, "GEMINI.md")],
+      kind: "file"
+    });
+  }
+  if (includeAgentFiles) {
+    const agentTargets = [
+      clients.has("factory") ? path3.join(roots.factoryRoot, "AGENTS.md") : null,
+      clients.has("codex") ? path3.join(roots.codexRoot, "AGENTS.md") : null,
+      clients.has("opencode") ? path3.join(roots.opencodeConfigRoot, "AGENTS.md") : null,
+      clients.has("ampcode") ? path3.join(roots.ampcodeConfigRoot, "AGENTS.md") : null
+    ].filter(Boolean);
+    if (agentTargets.length > 0) {
+      mappings.push({
+        name: "agents-md",
+        source: agentsFallback,
+        targets: agentTargets,
+        kind: "file"
+      });
+    }
+  }
+  mappings.push(
+    {
+      name: "commands",
+      source: path3.join(canonical, "commands"),
+      targets: [
+        clients.has("claude") ? path3.join(roots.claudeRoot, "commands") : null,
+        clients.has("factory") ? path3.join(roots.factoryRoot, "commands") : null,
+        clients.has("opencode") ? path3.join(roots.opencodeRoot, "commands") : null,
+        clients.has("cursor") ? path3.join(roots.cursorRoot, "commands") : null,
+        clients.has("gemini") ? path3.join(roots.geminiRoot, "commands") : null
+      ].filter(Boolean),
+      kind: "dir"
+    },
+    {
+      name: "hooks",
+      source: path3.join(canonical, "hooks"),
+      targets: [
+        clients.has("claude") ? path3.join(roots.claudeRoot, "hooks") : null,
+        clients.has("factory") ? path3.join(roots.factoryRoot, "hooks") : null
+      ].filter(Boolean),
+      kind: "dir"
+    },
+    {
+      name: "skills",
+      source: path3.join(canonical, "skills"),
+      targets: [
+        clients.has("claude") ? path3.join(roots.claudeRoot, "skills") : null,
+        clients.has("factory") ? path3.join(roots.factoryRoot, "skills") : null,
+        clients.has("gemini") && opts.scope === "global" ? path3.join(roots.geminiRoot, "config", "skills") : null
+      ].filter(Boolean),
+      kind: "dir"
+    }
+  );
+  return mappings;
+}
+
+// src/core/link-target.ts
+import path4 from "path";
+function getLinkTarget(source, target, kind) {
+  const resolvedSource = path4.resolve(source);
+  if (process.platform === "win32" && kind === "dir") {
+    return { link: resolvedSource, isRelative: false };
+  }
+  const relative = path4.relative(path4.dirname(target), resolvedSource);
+  if (!relative || path4.isAbsolute(relative)) {
+    return { link: resolvedSource, isRelative: false };
+  }
+  const resolvedRelative = path4.resolve(path4.dirname(target), relative);
+  if (resolvedRelative !== resolvedSource) {
+    return { link: resolvedSource, isRelative: false };
+  }
+  return { link: relative, isRelative: true };
+}
+
+// src/core/plan.ts
+async function getLinkTargetAbsolute(targetPath) {
+  try {
+    const link = await fs2.promises.readlink(targetPath);
+    if (!path5.isAbsolute(link)) {
+      return path5.resolve(path5.dirname(targetPath), link);
+    }
+    return link;
+  } catch {
+    return null;
+  }
+}
+async function ensureSourceTask(source, kind) {
+  const exists = await pathExists(source);
+  if (!exists) return [{ type: "ensure-source", path: source, kind }];
+  const stat = await fs2.promises.lstat(source);
+  if (kind === "file" && stat.isDirectory()) {
+    return [{ type: "conflict", source, target: source, reason: "Expected file but found directory", kind }];
+  }
+  if (kind === "dir" && !stat.isDirectory()) {
+    return [{ type: "conflict", source, target: source, reason: "Expected directory but found file", kind }];
+  }
+  return [];
+}
+async function analyzeTarget(source, target, kind, opts) {
+  const exists = await pathExists(target);
+  if (!exists) return { type: "link", source, target, kind };
+  const stat = await fs2.promises.lstat(target);
+  if (stat.isSymbolicLink()) {
+    const rawLink = await fs2.promises.readlink(target);
+    const resolved = await getLinkTargetAbsolute(target);
+    if (resolved && path5.resolve(resolved) === path5.resolve(source)) {
+      const desired = getLinkTarget(source, target, kind);
+      if (desired.isRelative && path5.isAbsolute(rawLink)) {
+        return { type: "link", source, target, kind, replaceSymlink: true };
+      }
+      return { type: "noop", source, target };
+    }
+    if (resolved && opts?.relinkableSources) {
+      const relinkable = new Set(opts.relinkableSources.map((p) => path5.resolve(p)));
+      if (relinkable.has(path5.resolve(resolved))) {
+        return { type: "link", source, target, kind, replaceSymlink: true };
+      }
+    }
+    const detail = resolved ? `Symlink points elsewhere: ${resolved}` : "Symlink points elsewhere";
+    return { type: "conflict", source, target, reason: detail, kind };
+  }
+  const targetKind = stat.isDirectory() ? "directory" : stat.isFile() ? "file" : "path";
+  return { type: "conflict", source, target, reason: `Target exists and is not a symlink (${targetKind})`, kind };
+}
+async function buildLinkPlan(opts) {
+  const mappings = await getMappings(opts);
+  const tasks = [];
+  for (const mapping of mappings) {
+    tasks.push(...await ensureSourceTask(mapping.source, mapping.kind));
+    let relinkableSources;
+    if (mapping.name === "claude-md") {
+      relinkableSources = [
+        path5.join(path5.dirname(mapping.source), "AGENTS.md"),
+        path5.join(path5.dirname(mapping.source), "CLAUDE.md")
+      ];
+    } else if (mapping.name === "gemini-md") {
+      relinkableSources = [
+        path5.join(path5.dirname(mapping.source), "AGENTS.md"),
+        path5.join(path5.dirname(mapping.source), "GEMINI.md")
+      ];
+    }
+    for (const target of mapping.targets) {
+      tasks.push(await analyzeTarget(mapping.source, target, mapping.kind, { relinkableSources }));
+    }
+  }
+  const conflicts = tasks.filter((t) => t.type === "conflict");
+  const changes = tasks.filter((t) => t.type === "link" || t.type === "ensure-source");
+  return { tasks, conflicts, changes };
+}
+
+// src/core/status.ts
+import fs3 from "fs";
+import path6 from "path";
+async function resolveLinkTarget(targetPath) {
+  try {
+    const link = await fs3.promises.readlink(targetPath);
+    if (!path6.isAbsolute(link)) return path6.resolve(path6.dirname(targetPath), link);
+    return link;
+  } catch {
+    return null;
+  }
+}
+async function getLinkStatus(opts) {
+  const mappings = await getMappings(opts);
+  const statuses = [];
+  for (const mapping of mappings) {
+    const targets = [];
+    for (const target of mapping.targets) {
+      const exists = await pathExists(target);
+      if (!exists) {
+        targets.push({ path: target, status: "missing" });
+        continue;
+      }
+      const stat = await fs3.promises.lstat(target);
+      if (stat.isSymbolicLink()) {
+        const resolved = await resolveLinkTarget(target);
+        if (resolved && path6.resolve(resolved) === path6.resolve(mapping.source)) {
+          targets.push({ path: target, status: "linked" });
+        } else {
+          targets.push({ path: target, status: "conflict" });
+        }
+        continue;
+      }
+      targets.push({ path: target, status: "conflict" });
+    }
+    statuses.push({ name: mapping.name, source: mapping.source, targets });
+  }
+  return statuses;
+}
+
+// src/core/migrate.ts
+import fs6 from "fs";
+import path10 from "path";
+
+// src/core/skills.ts
+import path7 from "path";
+import matter from "gray-matter";
+var NAME_RE = /^[a-z0-9-]{1,64}$/;
+async function parseSkillFile(skillFile) {
+  const raw = await readText(skillFile);
+  const parsed = matter(raw);
+  const data = parsed.data;
+  const name = String(data?.name || "").trim();
+  const description = String(data?.description || "").trim();
+  if (!name || !description) {
+    throw new Error(`SKILL.md missing required frontmatter fields (name, description): ${skillFile}`);
+  }
+  if (!NAME_RE.test(name)) {
+    throw new Error(`Skill name must be lowercase letters, numbers, and hyphens (max 64): ${name}`);
+  }
+  return {
+    name,
+    description,
+    allowedTools: Array.isArray(data?.["allowed-tools"]) ? data["allowed-tools"] : void 0,
+    model: typeof data?.model === "string" ? data.model : void 0
+  };
+}
+async function isSkillDir(dir) {
+  return await pathExists(path7.join(dir, "SKILL.md"));
+}
+async function findSkillDirs(root) {
+  const direct = await isSkillDir(root);
+  if (direct) return [root];
+  const skillsDir = path7.join(root, "skills");
+  const skillsDirExists = await pathExists(skillsDir);
+  if (skillsDirExists) {
+    const children2 = await listDirs(skillsDir);
+    const matches2 = [];
+    for (const child of children2) {
+      if (await isSkillDir(child)) matches2.push(child);
+    }
+    if (matches2.length) return matches2;
+  }
+  const children = await listDirs(root);
+  const matches = [];
+  for (const child of children) {
+    if (await isSkillDir(child)) matches.push(child);
+  }
+  return matches;
+}
+
+// src/core/apply.ts
+import fs5 from "fs";
+import path9 from "path";
+
+// src/core/backup.ts
+import fs4 from "fs";
+import path8 from "path";
+var MANIFEST_NAME = "manifest.json";
+function backupPathFor(target, backupRoot) {
+  const root = path8.parse(target).root || path8.sep;
+  const rel = path8.relative(root, target);
+  return path8.join(backupRoot, rel);
+}
+function hasParentPath(target, seen) {
+  const resolved = path8.resolve(target);
+  for (const parent of seen) {
+    if (resolved === parent) return true;
+    if (resolved.startsWith(parent + path8.sep)) return true;
+  }
+  return false;
+}
+async function backupSymlink(target, dest) {
+  const link = await fs4.promises.readlink(target);
+  await ensureDir(path8.dirname(dest));
+  await fs4.promises.symlink(link, dest);
+  await fs4.promises.unlink(target);
+}
+async function backupPathImpl(target, dest, kind) {
+  await ensureDir(path8.dirname(dest));
+  try {
+    await fs4.promises.rename(target, dest);
+    return;
+  } catch (err) {
+    if (err?.code !== "EXDEV") throw err;
+  }
+  if (kind === "dir") {
+    await copyDir(target, dest, true);
+  } else {
+    await copyFile(target, dest, true);
+  }
+  await removePath(target);
+}
+async function createBackupSession(opts) {
+  const timestamp = opts.timestamp || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const dir = path8.join(opts.canonicalRoot, "backup", timestamp);
+  await ensureDir(dir);
+  return {
+    dir,
+    manifestPath: path8.join(dir, MANIFEST_NAME),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    scope: opts.scope,
+    operation: opts.operation,
+    entries: [],
+    _seen: /* @__PURE__ */ new Set()
+  };
+}
+async function backupPath(target, session) {
+  if (!await pathExists(target)) return false;
+  const resolved = path8.resolve(target);
+  if (hasParentPath(resolved, session._seen)) return false;
+  const stat = await fs4.promises.lstat(target);
+  const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : "file";
+  const dest = backupPathFor(target, session.dir);
+  if (stat.isSymbolicLink()) {
+    await backupSymlink(target, dest);
+  } else {
+    await backupPathImpl(target, dest, kind);
+  }
+  session.entries.push({ originalPath: resolved, backupPath: dest, kind, action: "backup" });
+  session._seen.add(resolved);
+  return true;
+}
+function recordCreatedPath(target, kind, session) {
+  const resolved = path8.resolve(target);
+  if (hasParentPath(resolved, session._seen)) return;
+  session.entries.push({ originalPath: resolved, kind, action: "create" });
+  session._seen.add(resolved);
+}
+async function finalizeBackup(session) {
+  const manifest = {
+    version: 1,
+    createdAt: session.createdAt,
+    scope: session.scope,
+    operation: session.operation,
+    entries: session.entries
+  };
+  await fs4.promises.writeFile(session.manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+}
+async function loadBackupManifest(dir) {
+  const manifestPath = path8.join(dir, MANIFEST_NAME);
+  if (!await pathExists(manifestPath)) return null;
+  const raw = await fs4.promises.readFile(manifestPath, "utf8");
+  return JSON.parse(raw);
+}
+
+// src/core/apply.ts
+var DEFAULT_AGENTS = `# AGENTS
+
+Add shared agent instructions here.
+`;
+async function createSource(task) {
+  if (task.kind === "dir") {
+    await ensureDir(task.path);
+    return;
+  }
+  await ensureFile(task.path, DEFAULT_AGENTS);
+}
+async function createLink(source, target, kind, overwrite, backup) {
+  const linkTarget = getLinkTarget(source, target, kind);
+  if (await pathExists(target)) {
+    if (!overwrite) return { created: false, backedUp: false };
+    const backedUp = backup ? await backupPath(target, backup) : false;
+    if (await pathExists(target)) await removePath(target);
+    await ensureDir(path9.dirname(target));
+    const type2 = kind === "dir" ? "junction" : "file";
+    await fs5.promises.symlink(linkTarget.link, target, type2);
+    return { created: true, backedUp };
+  }
+  await ensureDir(path9.dirname(target));
+  const type = kind === "dir" ? "junction" : "file";
+  await fs5.promises.symlink(linkTarget.link, target, type);
+  return { created: true, backedUp: false };
+}
+async function applyLinkPlan(plan, opts) {
+  const force = !!opts?.force;
+  const backup = opts.backup;
+  if (!backup) throw new Error("Backup session required.");
+  let applied = 0;
+  let skipped = 0;
+  let conflicts = 0;
+  let backedUp = 0;
+  for (const task of plan.tasks) {
+    if (task.type === "conflict") {
+      conflicts += 1;
+      if (force && task.target !== task.source && task.kind) {
+        const result = await createLink(task.source, task.target, task.kind, true, backup);
+        if (result.backedUp) backedUp += 1;
+        applied += 1;
+      }
+      continue;
+    }
+    if (task.type === "noop") {
+      skipped += 1;
+      continue;
+    }
+    if (task.type === "ensure-source") {
+      await createSource(task);
+      recordCreatedPath(task.path, task.kind, backup);
+      applied += 1;
+      continue;
+    }
+    if (task.type === "link") {
+      const before = await pathExists(task.target);
+      let useForce = force;
+      if (!useForce && task.replaceSymlink && before) {
+        try {
+          const stat = await fs5.promises.lstat(task.target);
+          if (stat.isSymbolicLink()) useForce = true;
+        } catch {
+        }
+      }
+      const result = await createLink(task.source, task.target, task.kind, useForce, backup);
+      if (result.backedUp) backedUp += 1;
+      if (!before && result.created) {
+        recordCreatedPath(task.target, "symlink", backup);
+      }
+      if (before && !useForce) skipped += 1;
+      else applied += 1;
+    }
+  }
+  return { applied, skipped, conflicts, backupDir: backup.dir, backedUp };
+}
+
+// src/core/migrate.ts
+async function isSymlink(p) {
+  try {
+    const stat = await fs6.promises.lstat(p);
+    return stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function listFiles(dir) {
+  try {
+    const entries = await fs6.promises.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => path10.join(dir, e.name));
+  } catch {
+    return [];
+  }
+}
+function conflictLabel(targetPath, canonicalRoot) {
+  if (targetPath.startsWith(canonicalRoot)) {
+    const rel = path10.relative(canonicalRoot, targetPath);
+    return rel || path10.basename(targetPath);
+  }
+  return path10.basename(targetPath);
+}
+async function scanMigration(opts) {
+  const roots = resolveRoots(opts);
+  const canonicalRoot = roots.canonicalRoot;
+  const candidatesByTarget = /* @__PURE__ */ new Map();
+  const clients = new Set(opts.clients ?? ["claude", "factory", "codex", "cursor", "opencode", "gemini", "github", "ampcode"]);
+  const includeAgentFiles = opts.scope === "global";
+  const canonicalCommands = path10.join(canonicalRoot, "commands");
+  const canonicalHooks = path10.join(canonicalRoot, "hooks");
+  const canonicalSkills = path10.join(canonicalRoot, "skills");
+  const canonicalAgents = path10.join(canonicalRoot, "AGENTS.md");
+  const canonicalClaude = path10.join(canonicalRoot, "CLAUDE.md");
+  const opencodeSkillsRoot = opts.scope === "global" ? roots.opencodeConfigRoot : roots.opencodeRoot;
+  const sources = {
+    commands: [
+      clients.has("claude") ? { label: "Claude commands", dir: path10.join(roots.claudeRoot, "commands") } : null,
+      clients.has("factory") ? { label: "Factory commands", dir: path10.join(roots.factoryRoot, "commands") } : null,
+      clients.has("codex") ? { label: "Codex prompts", dir: path10.join(roots.codexRoot, "prompts") } : null,
+      clients.has("cursor") ? { label: "Cursor commands", dir: path10.join(roots.cursorRoot, "commands") } : null,
+      clients.has("opencode") ? { label: "OpenCode commands", dir: path10.join(roots.opencodeRoot, "commands") } : null,
+      clients.has("gemini") ? { label: "Gemini commands", dir: path10.join(roots.geminiRoot, "commands") } : null
+    ].filter(Boolean),
+    hooks: [
+      clients.has("claude") ? { label: "Claude hooks", dir: path10.join(roots.claudeRoot, "hooks") } : null,
+      clients.has("factory") ? { label: "Factory hooks", dir: path10.join(roots.factoryRoot, "hooks") } : null
+    ].filter(Boolean),
+    skills: [
+      clients.has("claude") ? { label: "Claude skills", dir: path10.join(roots.claudeRoot, "skills") } : null,
+      clients.has("factory") ? { label: "Factory skills", dir: path10.join(roots.factoryRoot, "skills") } : null,
+      clients.has("codex") ? { label: "Codex skills", dir: path10.join(roots.codexRoot, "skills") } : null,
+      clients.has("cursor") ? { label: "Cursor skills", dir: path10.join(roots.cursorRoot, "skills") } : null,
+      clients.has("opencode") ? { label: "OpenCode skills", dir: path10.join(opencodeSkillsRoot, "skills") } : null,
+      clients.has("gemini") && opts.scope === "global" ? { label: "Gemini global skills", dir: path10.join(roots.geminiRoot, "config", "skills") } : null,
+      clients.has("gemini") ? { label: "Gemini legacy skills", dir: path10.join(roots.geminiRoot, "skills") } : null,
+      // GitHub uses .github/skills for project scope and ~/.copilot/skills for global scope.
+      clients.has("github") ? opts.scope === "global" ? { label: "GitHub Copilot skills", dir: path10.join(roots.copilotRoot, "skills") } : { label: "GitHub skills", dir: path10.join(roots.githubRoot, "skills") } : null
+    ].filter(Boolean),
+    agents: includeAgentFiles ? [
+      clients.has("claude") ? { label: "Claude AGENTS.md", file: path10.join(roots.claudeRoot, "AGENTS.md") } : null,
+      clients.has("factory") ? { label: "Factory AGENTS.md", file: path10.join(roots.factoryRoot, "AGENTS.md") } : null,
+      clients.has("codex") ? { label: "Codex AGENTS.md", file: path10.join(roots.codexRoot, "AGENTS.md") } : null,
+      clients.has("opencode") ? { label: "OpenCode AGENTS.md", file: path10.join(roots.opencodeConfigRoot, "AGENTS.md") } : null,
+      clients.has("ampcode") ? { label: "Ampcode AGENTS.md", file: path10.join(roots.ampcodeConfigRoot, "AGENTS.md") } : null
+    ].filter(Boolean) : [],
+    claude: includeAgentFiles ? [
+      clients.has("claude") ? { label: "Claude CLAUDE.md", file: path10.join(roots.claudeRoot, "CLAUDE.md") } : null
+    ].filter(Boolean) : [],
+    gemini: includeAgentFiles ? [
+      clients.has("gemini") ? { label: "Gemini GEMINI.md", file: path10.join(roots.geminiRoot, "GEMINI.md") } : null
+    ].filter(Boolean) : []
+  };
+  const addCandidate = (candidate) => {
+    const list = candidatesByTarget.get(candidate.targetPath) || [];
+    list.push(candidate);
+    candidatesByTarget.set(candidate.targetPath, list);
+  };
+  for (const src of sources.commands) {
+    if (!await pathExists(src.dir) || await isSymlink(src.dir)) continue;
+    const files = await listFiles(src.dir);
+    for (const file of files) {
+      const targetPath = path10.join(canonicalCommands, path10.basename(file));
+      addCandidate({ label: src.label, targetPath, kind: "file", action: "copy", sourcePath: file });
+    }
+  }
+  for (const src of sources.hooks) {
+    if (!await pathExists(src.dir) || await isSymlink(src.dir)) continue;
+    const files = await listFiles(src.dir);
+    for (const file of files) {
+      const targetPath = path10.join(canonicalHooks, path10.basename(file));
+      addCandidate({ label: src.label, targetPath, kind: "file", action: "copy", sourcePath: file });
+    }
+  }
+  for (const src of sources.skills) {
+    if (!await pathExists(src.dir) || await isSymlink(src.dir)) continue;
+    const skillDirs = await findSkillDirs(src.dir);
+    for (const dir of skillDirs) {
+      try {
+        const meta = await parseSkillFile(path10.join(dir, "SKILL.md"));
+        const targetPath = path10.join(canonicalSkills, meta.name);
+        addCandidate({ label: src.label, targetPath, kind: "dir", action: "copy", sourcePath: dir });
+      } catch {
+      }
+    }
+  }
+  for (const src of sources.agents) {
+    if (!await pathExists(src.file) || await isSymlink(src.file)) continue;
+    addCandidate({ label: src.label, targetPath: canonicalAgents, kind: "file", action: "copy", sourcePath: src.file });
+  }
+  for (const src of sources.claude) {
+    if (!await pathExists(src.file) || await isSymlink(src.file)) continue;
+    addCandidate({ label: src.label, targetPath: canonicalClaude, kind: "file", action: "copy", sourcePath: src.file });
+  }
+  const canonicalGemini = path10.join(canonicalRoot, "GEMINI.md");
+  for (const src of sources.gemini) {
+    if (!await pathExists(src.file) || await isSymlink(src.file)) continue;
+    addCandidate({ label: src.label, targetPath: canonicalGemini, kind: "file", action: "copy", sourcePath: src.file });
+  }
+  const auto = [];
+  const conflicts = [];
+  for (const [targetPath, list] of candidatesByTarget.entries()) {
+    const canonicalExists = await pathExists(targetPath);
+    if (canonicalExists) {
+      let kind = "file";
+      try {
+        const stat = await fs6.promises.lstat(targetPath);
+        kind = stat.isDirectory() ? "dir" : "file";
+      } catch {
+      }
+      list.unshift({
+        label: "Keep existing (.agents)",
+        targetPath,
+        kind,
+        action: "keep"
+      });
+    }
+    if (list.length === 1 && !canonicalExists) {
+      const only = list[0];
+      if (only) auto.push(only);
+      continue;
+    }
+    conflicts.push({
+      label: conflictLabel(targetPath, canonicalRoot),
+      targetPath,
+      candidates: list
+    });
+  }
+  return { auto, conflicts, canonicalRoot };
+}
+async function applyMigration(plan, selections, opts) {
+  const backup = opts.backup;
+  if (!backup) throw new Error("Backup session required.");
+  let copied = 0;
+  let skipped = 0;
+  const copyCandidate = async (candidate) => {
+    if (candidate.action !== "copy" || !candidate.sourcePath) return false;
+    const existed = await pathExists(candidate.targetPath);
+    if (existed) {
+      await backupPath(candidate.targetPath, backup);
+    } else {
+      recordCreatedPath(candidate.targetPath, candidate.kind === "dir" ? "dir" : "file", backup);
+    }
+    if (candidate.kind === "file") {
+      await copyFile(candidate.sourcePath, candidate.targetPath, true);
+    } else {
+      await copyDir(candidate.sourcePath, candidate.targetPath, true);
+    }
+    return true;
+  };
+  for (const candidate of plan.auto) {
+    if (await copyCandidate(candidate)) copied += 1;
+    else skipped += 1;
+  }
+  for (const conflict of plan.conflicts) {
+    const choice = selections.get(conflict.targetPath);
+    if (!choice || choice.action !== "copy") {
+      skipped += 1;
+      continue;
+    }
+    if (await copyCandidate(choice)) copied += 1;
+    else skipped += 1;
+  }
+  const linkPlan = await buildLinkPlan(opts);
+  const linkResult = await applyLinkPlan(linkPlan, { force: !!opts.forceLinks, backup });
+  return {
+    copied,
+    skipped,
+    backupDir: backup.dir,
+    links: {
+      applied: linkResult.applied,
+      skipped: linkResult.skipped,
+      conflicts: linkResult.conflicts,
+      backedUp: linkResult.backedUp
+    }
+  };
+}
+
+// src/core/undo.ts
+import fs7 from "fs";
+import path11 from "path";
+async function listBackupDirs(canonicalRoot) {
+  const root = path11.join(canonicalRoot, "backup");
+  if (!await pathExists(root)) return [];
+  const entries = await fs7.promises.readdir(root, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => path11.join(root, e.name));
+}
+async function findLatestBackup(canonicalRoot) {
+  const dirs = await listBackupDirs(canonicalRoot);
+  const manifests = [];
+  for (const dir of dirs) {
+    const manifest = await loadBackupManifest(dir);
+    if (manifest) manifests.push({ dir, manifest });
+  }
+  if (!manifests.length) return null;
+  manifests.sort((a, b) => a.manifest.createdAt.localeCompare(b.manifest.createdAt));
+  return manifests[manifests.length - 1] || null;
+}
+async function restoreSymlink(entry) {
+  if (!entry.backupPath) return;
+  const link = await fs7.promises.readlink(entry.backupPath);
+  await ensureDir(path11.dirname(entry.originalPath));
+  await fs7.promises.symlink(link, entry.originalPath);
+  await fs7.promises.unlink(entry.backupPath);
+}
+async function restorePath(entry) {
+  if (entry.action === "create") {
+    await removePath(entry.originalPath);
+    return;
+  }
+  if (!entry.backupPath) return;
+  if (entry.kind === "symlink") {
+    await restoreSymlink(entry);
+    return;
+  }
+  await ensureDir(path11.dirname(entry.originalPath));
+  try {
+    await fs7.promises.rename(entry.backupPath, entry.originalPath);
+    return;
+  } catch (err) {
+    if (err?.code !== "EXDEV") throw err;
+  }
+  if (entry.kind === "dir") {
+    await fs7.promises.cp(entry.backupPath, entry.originalPath, { recursive: true, force: true });
+  } else {
+    await fs7.promises.copyFile(entry.backupPath, entry.originalPath);
+  }
+  await removePath(entry.backupPath);
+}
+async function backupExistingOriginals(entries, session) {
+  for (const entry of entries) {
+    if (!await pathExists(entry.originalPath)) continue;
+    await backupPath(entry.originalPath, session);
+  }
+}
+async function undoLastChange(opts) {
+  const roots = resolveRoots(opts);
+  const latest = await findLatestBackup(roots.canonicalRoot);
+  if (!latest) throw new Error("No backups found to undo.");
+  const undoSession = await createBackupSession({
+    canonicalRoot: roots.canonicalRoot,
+    scope: opts.scope,
+    operation: "undo"
+  });
+  const entries = latest.manifest.entries || [];
+  await backupExistingOriginals(entries, undoSession);
+  let restored = 0;
+  let restoredBackups = 0;
+  let removedCreated = 0;
+  let removedSymlinks = 0;
+  for (const entry of entries) {
+    if (entry.action === "create") {
+      if (await pathExists(entry.originalPath)) {
+        await restorePath(entry);
+        restored += 1;
+        removedCreated += 1;
+        if (entry.kind === "symlink") removedSymlinks += 1;
+      }
+      continue;
+    }
+    if (!entry.backupPath) continue;
+    if (!await pathExists(entry.backupPath)) continue;
+    await restorePath(entry);
+    restored += 1;
+    restoredBackups += 1;
+  }
+  await finalizeBackup(undoSession);
+  return { restored, restoredBackups, removedCreated, removedSymlinks, backupDir: undoSession.dir, undoneDir: latest.dir };
+}
+
+// src/core/preflight.ts
+import fs8 from "fs";
+import path12 from "path";
+async function needsLinkBackup(task, forceLinks) {
+  if (task.type === "conflict") return forceLinks && task.target !== task.source;
+  if (task.type !== "link") return false;
+  if (!await pathExists(task.target)) return false;
+  if (forceLinks) return true;
+  if (!task.replaceSymlink) return false;
+  try {
+    const stat = await fs8.promises.lstat(task.target);
+    return stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function collectMigrationCandidates(plan, selections) {
+  const candidates = [...plan.auto];
+  for (const conflict of plan.conflicts) {
+    const choice = selections.get(conflict.targetPath);
+    if (choice && choice.action === "copy") candidates.push(choice);
+  }
+  return candidates;
+}
+async function preflightBackup(opts) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const task of opts.linkPlan.tasks) {
+    if ((task.type === "conflict" || task.type === "link") && await needsLinkBackup(task, opts.forceLinks)) {
+      targets.add(path12.resolve(task.target));
+    }
+  }
+  const migrationCandidates = collectMigrationCandidates(opts.migratePlan, opts.selections);
+  for (const candidate of migrationCandidates) {
+    if (!candidate.sourcePath) continue;
+    if (await pathExists(candidate.targetPath)) {
+      targets.add(path12.resolve(candidate.targetPath));
+    }
+  }
+  for (const target of targets) {
+    const exists = await pathExists(target);
+    if (!exists) continue;
+    const stat = await fs8.promises.lstat(target);
+    if (stat.isSymbolicLink()) {
+      await fs8.promises.readlink(target);
+    }
+    const dest = backupPathFor(target, opts.backup.dir);
+    await ensureDir(path12.dirname(dest));
+    await fs8.promises.access(path12.dirname(dest), fs8.constants.W_OK);
+  }
+  return { targets: targets.size };
+}
+
+// src/cli.tsx
+var appTitle = "dotagents";
+function exitCancelled() {
+  cancel("Cancelled");
+  process.exit(0);
+}
+function mergeAgentStatus(items) {
+  const claudeEntry = items.find((s) => s.name === "claude-md") || null;
+  const geminiEntry = items.find((s) => s.name === "gemini-md") || null;
+  const agentsEntry = items.find((s) => s.name === "agents-md") || null;
+  if (!claudeEntry && !agentsEntry && !geminiEntry) return items;
+  const merged = {
+    name: "agents-md",
+    source: claudeEntry?.source || geminiEntry?.source || agentsEntry?.source || "",
+    targets: [
+      ...claudeEntry?.targets || [],
+      ...geminiEntry?.targets || [],
+      ...agentsEntry?.targets || []
+    ]
+  };
+  const withoutAgents = items.filter((s) => s.name !== "claude-md" && s.name !== "gemini-md" && s.name !== "agents-md");
+  return [merged, ...withoutAgents];
+}
+function displayName(entry) {
+  if (entry.name === "agents-md") {
+    const sourceFile = path13.basename(entry.source);
+    if (sourceFile === "CLAUDE.md") return "AGENTS.md (Claude override)";
+    if (sourceFile === "GEMINI.md") return "AGENTS.md (Gemini override)";
+    return "AGENTS.md";
+  }
+  return entry.name;
+}
+function buildStatusSummary(status) {
+  return status.map((s) => {
+    const linked = s.targets.filter((t) => t.status === "linked").length;
+    const missing = s.targets.filter((t) => t.status === "missing").length;
+    const conflict = s.targets.filter((t) => t.status === "conflict").length;
+    return { name: displayName(s), linked, missing, conflict };
+  });
+}
+function formatSummaryTable(rows) {
+  const header = { name: "Section", conflict: "Conflicts", missing: "Need link", linked: "Linked" };
+  const width = {
+    name: Math.max(header.name.length, ...rows.map((r) => r.name.length)),
+    conflict: Math.max(header.conflict.length, ...rows.map((r) => String(r.conflict).length)),
+    missing: Math.max(header.missing.length, ...rows.map((r) => String(r.missing).length)),
+    linked: Math.max(header.linked.length, ...rows.map((r) => String(r.linked).length))
+  };
+  const pad = (value, len) => value.padEnd(len, " ");
+  const lines = [
+    `${pad(header.name, width.name)}  ${pad(header.conflict, width.conflict)}  ${pad(header.missing, width.missing)}  ${pad(header.linked, width.linked)}`,
+    ...rows.map((r) => `${pad(r.name, width.name)}  ${pad(String(r.conflict), width.conflict)}  ${pad(String(r.missing), width.missing)}  ${pad(String(r.linked), width.linked)}`)
+  ];
+  return lines;
+}
+function renderStatusLines(status, conflictReasons) {
+  const lines = [];
+  for (const entry of status) {
+    lines.push(chalk.cyan(displayName(entry)));
+    for (const target of entry.targets) {
+      const icon = target.status === "linked" ? chalk.green("\u2713") : target.status === "missing" ? chalk.yellow("\u2022") : chalk.red("\u26A0");
+      const reason = target.status === "conflict" ? conflictReasons.get(target.path) : void 0;
+      lines.push(`  ${icon} ${target.path}${reason ? chalk.dim(` \u2014 ${reason}`) : ""}`);
+    }
+  }
+  return lines;
+}
+async function selectScope() {
+  const scope = await select({
+    message: "Choose a workspace",
+    options: [
+      { label: "Global (~/.agents)", value: "global" },
+      { label: "Project (.agents)", value: "project" },
+      { label: "Exit", value: "exit" }
+    ]
+  });
+  if (isCancel(scope)) exitCancelled();
+  if (scope === "exit") {
+    outro("Bye");
+    process.exit(0);
+  }
+  return scope;
+}
+function scopeLabel(scope) {
+  return scope === "global" ? "Global (~/.agents)" : "Project (.agents)";
+}
+function pluralize(count, singular, plural) {
+  return count === 1 ? singular : plural || `${singular}s`;
+}
+function formatCount(count, singular, plural) {
+  return `${count} ${pluralize(count, singular, plural)}`;
+}
+async function selectClients() {
+  const options = [
+    { label: "Claude", value: "claude" },
+    { label: "Factory", value: "factory" },
+    { label: "Codex", value: "codex" },
+    { label: "Cursor", value: "cursor" },
+    { label: "OpenCode", value: "opencode" },
+    { label: "Gemini", value: "gemini" },
+    { label: "GitHub", value: "github" },
+    { label: "Ampcode", value: "ampcode" }
+  ];
+  const selected = await multiselect({
+    message: "Select clients to manage",
+    options: options.map((opt) => ({ label: opt.label, value: opt.value })),
+    initialValues: options.map((opt) => opt.value),
+    required: true
+  });
+  if (isCancel(selected)) exitCancelled();
+  return selected;
+}
+function formatClients(clients) {
+  const names = {
+    claude: "Claude",
+    factory: "Factory",
+    codex: "Codex",
+    cursor: "Cursor",
+    opencode: "OpenCode",
+    gemini: "Gemini",
+    github: "GitHub",
+    ampcode: "Ampcode"
+  };
+  return clients.map((c) => names[c]).join(", ");
+}
+async function showStatus(scope, clients, status, planConflicts) {
+  const conflicts = new Map(planConflicts.map((c) => [c.target, c.reason]));
+  const lines = renderStatusLines(mergeAgentStatus(status), conflicts);
+  note(lines.join("\n"), `Status \xB7 ${scopeLabel(scope)} \xB7 ${formatClients(clients)}`);
+}
+async function resolveMigrationConflicts(plan) {
+  const selections = /* @__PURE__ */ new Map();
+  for (let i = 0; i < plan.conflicts.length; i += 1) {
+    const conflict = plan.conflicts[i];
+    if (!conflict) continue;
+    const choice = await select({
+      message: `Resolve migration conflict ${i + 1} of ${plan.conflicts.length}: ${conflict.label}`,
+      options: conflict.candidates.map((c) => ({ label: c.label, value: c }))
+    });
+    if (isCancel(choice)) return null;
+    selections.set(conflict.targetPath, choice);
+  }
+  return selections;
+}
+async function runChange(scope, clients) {
+  const spin = spinner();
+  spin.start("Scanning current setup...");
+  const roots = resolveRoots({ scope });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const migrate = await scanMigration({ scope, clients });
+  const link = await buildLinkPlan({ scope, clients });
+  const backupDir = path13.join(roots.canonicalRoot, "backup", timestamp);
+  spin.stop("Scan complete");
+  const planSummary = [
+    `Migration: ${migrate.auto.length} auto \xB7 ${migrate.conflicts.length} conflicts (choose sources)`,
+    `Links: ${link.changes.length} changes \xB7 ${link.conflicts.length} conflicts (existing files/dirs)`,
+    `Backup: ${backupDir}`,
+    'Undo: Use "Undo last change" after this completes.'
+  ].join("\n");
+  note(planSummary, "Plan summary");
+  let overwriteConflicts = true;
+  if (link.conflicts.length > 0) {
+    const choice = await select({
+      message: "Apply changes",
+      options: [
+        { label: "Apply changes + overwrite conflicts", value: "force" },
+        { label: "Apply changes (leave conflicts)", value: "skip" },
+        { label: "Back", value: "back" }
+      ]
+    });
+    if (isCancel(choice)) return;
+    if (choice === "back") return;
+    overwriteConflicts = choice === "force";
+  } else {
+    const ok = await confirm({ message: "Apply changes now?" });
+    if (isCancel(ok) || !ok) return;
+  }
+  let selections = /* @__PURE__ */ new Map();
+  if (migrate.conflicts.length > 0) {
+    const resolved = await resolveMigrationConflicts(migrate);
+    if (!resolved) return;
+    selections = resolved;
+  }
+  const applySpinner = spinner();
+  applySpinner.start("Applying changes...");
+  try {
+    const backup = await createBackupSession({
+      canonicalRoot: roots.canonicalRoot,
+      scope,
+      operation: "change-to-agents",
+      timestamp
+    });
+    await preflightBackup({
+      backup,
+      linkPlan: link,
+      migratePlan: migrate,
+      selections,
+      forceLinks: overwriteConflicts
+    });
+    const result = await applyMigration(migrate, selections, { scope, clients, backup, forceLinks: overwriteConflicts });
+    await finalizeBackup(backup);
+    const migrationSummary = `Migrated ${formatCount(result.copied, "item")}`;
+    const linkSummary = `Linked ${formatCount(result.links.applied, "path")}`;
+    const conflictSummary = result.links.conflicts > 0 ? overwriteConflicts ? `overwrote ${formatCount(result.links.conflicts, "conflict")}` : `left ${formatCount(result.links.conflicts, "conflict")} untouched` : "";
+    const pieces = [migrationSummary, linkSummary];
+    if (conflictSummary) pieces.push(conflictSummary);
+    applySpinner.stop(`${pieces.join(" \xB7 ")}. Backup: ${result.backupDir}`);
+  } catch (err) {
+    applySpinner.stop("Change failed");
+    note(String(err?.message || err), "Error");
+  }
+}
+async function run() {
+  intro(chalk.cyan(appTitle));
+  const scope = await selectScope();
+  let clients = await selectClients();
+  while (true) {
+    const status = mergeAgentStatus(await getLinkStatus({ scope, clients }));
+    const plan = await buildLinkPlan({ scope, clients });
+    const conflicts = plan.conflicts.length || 0;
+    const changes = plan.changes.length || 0;
+    const summary = buildStatusSummary(status);
+    const summaryLines = formatSummaryTable(summary);
+    note([
+      `Scope: ${scopeLabel(scope)}`,
+      `Clients: ${formatClients(clients)}`,
+      `Pending changes: ${changes} \xB7 Conflicts: ${conflicts}`,
+      ...summaryLines
+    ].join("\n"), "Overview");
+    const options = [];
+    if (changes > 0 || conflicts > 0) {
+      const label = conflicts > 0 && changes === 0 ? `Resolve ${conflicts} ${pluralize(conflicts, "conflict")}` : `Apply ${changes} ${pluralize(changes, "change")}`;
+      options.push({ label, value: "change" });
+    }
+    options.push({ label: "View status", value: "status" });
+    options.push({ label: "Change clients", value: "clients" });
+    options.push({ label: "Undo last change", value: "undo" });
+    options.push({ label: "Exit", value: "exit" });
+    const action = await select({ message: "Choose an action", options });
+    if (isCancel(action)) exitCancelled();
+    if (action === "exit") break;
+    if (action === "status") {
+      await showStatus(scope, clients, status, plan.conflicts);
+      continue;
+    }
+    if (action === "clients") {
+      clients = await selectClients();
+      continue;
+    }
+    if (action === "undo") {
+      const spin = spinner();
+      spin.start("Undoing last change...");
+      try {
+        const result = await undoLastChange({ scope });
+        const restoredSummary = `Restored ${formatCount(result.restoredBackups, "backup")}`;
+        const removedSummary = `Removed ${formatCount(result.removedCreated, "created path")}`;
+        const symlinkSummary = result.removedSymlinks > 0 ? `${formatCount(result.removedSymlinks, "symlink")} removed` : "";
+        let totalSummary = "";
+        if (result.restoredBackups === 0 && result.removedCreated === 0) {
+          totalSummary = "Nothing to undo.";
+        } else if (result.restoredBackups === 0) {
+          totalSummary = [removedSummary, symlinkSummary, "No backups to restore."].filter(Boolean).join(" \xB7 ");
+        } else {
+          totalSummary = [restoredSummary, removedSummary, symlinkSummary].filter(Boolean).join(" \xB7 ");
+        }
+        spin.stop(`${totalSummary} Reverted: ${result.undoneDir}`);
+        note(`Undo backup: ${result.backupDir}`, "Undo log");
+      } catch (err) {
+        spin.stop("Undo failed");
+        note(String(err?.message || err), "Error");
+      }
+      continue;
+    }
+    if (action === "change") {
+      await runChange(scope, clients);
+    }
+  }
+  outro("Bye");
+}
+run().catch((err) => {
+  note(String(err?.message || err), "Fatal error");
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@hurst05/dotagents",
+  "version": "0.1.3",
+  "description": "Canonical .agents manager with symlinks for popular AI tools",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "dotagents": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsup src/cli.tsx --format esm --platform node --out-dir dist --clean",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm test && npm run type-check && npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "chalk": "^5.4.1",
+    "gray-matter": "^4.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "overrides": {
+    "esbuild": "^0.28.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}