arcane-cli 1.12.3 → 1.13.0

package/dist/index.js

@@ -6,7 +6,7 @@ const require = __createRequire(import.meta.url);
 import { Command } from "commander";
 import { createRequire as createRequire3 } from "module";
 import { fileURLToPath } from "url";
-import { dirname as dirname13, join as join23 } from "path";
+import { dirname as dirname14, join as join23 } from "path";
 
 // src/commands/init.ts
 import { select as select3, confirm as confirm2, input as input3 } from "@inquirer/prompts";
@@ -14,6 +14,7 @@ import { dirname as dirname5, join as join8 } from "path";
 import chalk2 from "chalk";
 
 // src/modules/copier.ts
+import { lstatSync } from "fs";
 import {
   mkdir,
   access,
@@ -123,7 +124,7 @@ function buildGitEnv() {
 function runGit(cwd, args, options = {}) {
   const commandClass = options.commandClass ?? classifyGitCommand(args);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUTS_MS[commandClass] ?? DEFAULT_TIMEOUTS_MS.write;
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = execFile(
       "git",
       args,
@@ -157,7 +158,7 @@ function runGit(cwd, args, options = {}) {
           reject(error);
           return;
         }
-        resolve6({ stdout, stderr });
+        resolve10({ stdout, stderr });
       }
     );
     child.stdin?.end();
@@ -295,6 +296,24 @@ async function isUneditedTrackedFile(cwd, relativePath) {
   return { verdict: "unedited", detail: "tracked, clean, and added by its only commit" };
 }
 
+// src/modules/real-path.ts
+import { realpathSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+function resolveRealPath(path4) {
+  const missing = [];
+  let existing = path4;
+  for (; ; ) {
+    try {
+      return join(realpathSync.native(existing), ...missing);
+    } catch {
+      const parent = dirname(existing);
+      if (parent === existing) return resolve(path4);
+      missing.unshift(basename(existing));
+      existing = parent;
+    }
+  }
+}
+
 // src/modules/copier.ts
 function normalizeLineEndings(content) {
   if (!content.includes(13)) return content;
@@ -332,6 +351,77 @@ function validateTargetPath(targetDir, relativePath) {
     );
   }
 }
+var LinkedDirectoryError = class extends Error {
+  constructor(relativePath, escape, targetDir) {
+    super(
+      `Linked directory: "${relativePath}" ${escape.link === relativePath ? "is" : `is under "${escape.link}",`} a link to "${escape.resolvesTo}" outside target directory "${targetDir}". Arcane writes and deletes managed files only inside the target directory: replace the link with a directory, then run the command again.`
+    );
+    this.relativePath = relativePath;
+    this.escape = escape;
+    this.name = "LinkedDirectoryError";
+  }
+  relativePath;
+  escape;
+};
+function isWithin(base, candidate) {
+  return candidate === base || candidate.startsWith(base.endsWith(path.sep) ? base : base + path.sep);
+}
+function findLinkedEscape(targetDir, relativeDir) {
+  const base = path.resolve(targetDir);
+  const dir = path.resolve(base, relativeDir);
+  if (!isWithin(base, dir) || dir === base) return null;
+  const realBase = resolveRealPath(base);
+  const realDir = resolveRealPath(dir);
+  if (isWithin(realBase, realDir)) return null;
+  const parts = path.relative(base, dir).split(path.sep);
+  let current = base;
+  for (let i = 0; i < parts.length; i++) {
+    current = path.join(current, parts[i]);
+    let isLink;
+    try {
+      isLink = lstatSync(current).isSymbolicLink();
+    } catch {
+      break;
+    }
+    if (!isLink) continue;
+    const resolvesTo = resolveRealPath(current);
+    if (!isWithin(realBase, resolvesTo)) return { link: parts.slice(0, i + 1).join("/"), resolvesTo };
+  }
+  return { link: parts.join("/"), resolvesTo: realDir };
+}
+function validateRealTargetPath(targetDir, relativePath) {
+  validateTargetPath(targetDir, relativePath);
+  const escape = findLinkedEscape(targetDir, path.dirname(relativePath));
+  if (escape !== null) throw new LinkedDirectoryError(relativePath, escape, targetDir);
+}
+function validateRealTargetDirectory(targetDir, relativeDir) {
+  validateTargetPath(targetDir, relativeDir);
+  const escape = findLinkedEscape(targetDir, relativeDir);
+  if (escape !== null) throw new LinkedDirectoryError(relativeDir, escape, targetDir);
+}
+function findLinkedEscapes(targetDir, files) {
+  const byDirectory = /* @__PURE__ */ new Map();
+  const byLink = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dir = path.dirname(file);
+    if (!byDirectory.has(dir)) byDirectory.set(dir, findLinkedEscape(targetDir, dir));
+    const escape = byDirectory.get(dir);
+    if (escape == null) continue;
+    const seen = byLink.get(escape.link);
+    if (seen === void 0) byLink.set(escape.link, { ...escape, count: 1 });
+    else seen.count++;
+  }
+  return [...byLink.values()];
+}
+function describeLinkedEscapes(targetDir, escapes) {
+  return escapes.map(
+    (e) => `  \u2717 "${e.link}" is a link to "${e.resolvesTo}", outside "${path.resolve(targetDir)}": ${e.count} managed path${e.count === 1 ? "" : "s"} under it.`
+  );
+}
+function validateManagedPath(targetDir, relativePath, opts) {
+  if (opts.followDirectoryLinks) validateTargetPath(targetDir, relativePath);
+  else validateRealTargetPath(targetDir, relativePath);
+}
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
@@ -380,7 +470,7 @@ async function managedPathLinkShape(targetDir, relativePath, linkTracked, bodyHe
   }
 }
 async function writeManagedFile(targetDir, relativePath, content, opts = {}) {
-  validateTargetPath(targetDir, relativePath);
+  validateManagedPath(targetDir, relativePath, opts);
   const destPath = path.resolve(targetDir, relativePath);
   await ensureDir(path.dirname(destPath));
   const shape = await replaceSymlinkedDestination(destPath, relativePath, opts);
@@ -389,7 +479,7 @@ async function writeManagedFile(targetDir, relativePath, content, opts = {}) {
   if (shape !== null) opts.conversions?.push({ file: relativePath, shape });
 }
 async function copyFile(srcPath, targetDir, relativePath, opts = {}) {
-  validateTargetPath(targetDir, relativePath);
+  validateManagedPath(targetDir, relativePath, opts);
   const destPath = path.resolve(targetDir, relativePath);
   await ensureDir(path.dirname(destPath));
   if (!opts.force && await fileExists(destPath)) {
@@ -402,12 +492,12 @@ async function copyFile(srcPath, targetDir, relativePath, opts = {}) {
   await writeManagedFile(targetDir, relativePath, content, opts);
   return hash;
 }
-async function removeWithin(targetDir, relativePath) {
-  validateTargetPath(targetDir, relativePath);
+async function removeWithin(targetDir, relativePath, opts = {}) {
+  validateManagedPath(targetDir, relativePath, opts);
   await rm(path.resolve(targetDir, relativePath), { force: true });
 }
-async function removeEmptyAncestors(targetDir, relativePath) {
-  validateTargetPath(targetDir, relativePath);
+async function removeEmptyAncestors(targetDir, relativePath, opts = {}) {
+  validateManagedPath(targetDir, relativePath, opts);
   const base = path.resolve(targetDir);
   let dir = path.dirname(path.resolve(targetDir, relativePath));
   while (dir !== base && dir.startsWith(base + path.sep)) {
@@ -1294,7 +1384,7 @@ function listProfiles() {
 // src/modules/user-tier.ts
 import { lstat as lstat2, mkdir as mkdir2, readdir as readdir2, readFile as readFile3, rm as rm2, rmdir as rmdir2, writeFile as writeFile3 } from "fs/promises";
 import { homedir } from "os";
-import { dirname, join, resolve } from "path";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
 
 // src/modules/spell-compiler.ts
 import { parse as parseYaml } from "yaml";
@@ -1395,7 +1485,7 @@ function resolveHomeDir() {
   return homedir();
 }
 function userTierRoot(homeDir = resolveHomeDir()) {
-  return join(homeDir, USER_TIER_DIR_NAME);
+  return join2(homeDir, USER_TIER_DIR_NAME);
 }
 var USER_TIER_COMPONENTS = SPELL_COMPONENT_NAMES;
 var CANONICAL_SPELL_PATH_PATTERN = /^\.arcane\/spells\/(spell-[a-z0-9-]+)\.md$/;
@@ -1410,7 +1500,7 @@ function spellIdFromStorePath(path4) {
   return path4.replace(/\\/g, "/").match(STORE_SPELL_PATH_PATTERN)?.[1];
 }
 function absoluteStoreSpellPath(storeRoot, id) {
-  return resolve(storeRoot, storeSpellPath(id)).replace(/\\/g, "/");
+  return resolve2(storeRoot, storeSpellPath(id)).replace(/\\/g, "/");
 }
 function componentForScope(component, scope) {
   if (scope === "repo") return component;
@@ -1471,8 +1561,8 @@ function clientOfFanoutPath(relativePath) {
 }
 async function readSpellSource(storeRoot, id, fallbackDir) {
   for (const candidate of [
-    join(storeRoot, storeSpellPath(id)),
-    ...fallbackDir ? [join(fallbackDir, canonicalSpellPath(id))] : []
+    join2(storeRoot, storeSpellPath(id)),
+    ...fallbackDir ? [join2(fallbackDir, canonicalSpellPath(id))] : []
   ]) {
     try {
       return await readFile3(candidate, "utf-8");
@@ -1517,7 +1607,7 @@ async function classifyTarget(path4) {
 }
 function perSpellDirectory(homeDir, relativePath) {
   if (clientOfFanoutPath(relativePath) !== "codex") return void 0;
-  return dirname(join(homeDir, relativePath));
+  return dirname2(join2(homeDir, relativePath));
 }
 async function removeDirectoryIfEmpty(dir) {
   try {
@@ -1546,13 +1636,13 @@ async function syncUserTierFanout(options) {
   }
   for (const file of desired) {
     validateTargetPath(options.homeDir, file.relativePath);
-    const target = join(options.homeDir, file.relativePath);
+    const target = join2(options.homeDir, file.relativePath);
     const recorded = previous[file.relativePath];
     const newHash = hashContent(file.content);
     const state = await classifyTarget(target);
     if (state === "absent") {
       if (!dryRun) {
-        await mkdir2(dirname(target), { recursive: true });
+        await mkdir2(dirname2(target), { recursive: true });
         await writeFile3(target, file.content, "utf-8");
       }
       record[file.relativePath] = newHash;
@@ -1585,7 +1675,7 @@ async function syncUserTierFanout(options) {
       continue;
     }
     validateTargetPath(options.homeDir, relativePath);
-    const target = join(options.homeDir, relativePath);
+    const target = join2(options.homeDir, relativePath);
     const state = await classifyTarget(target);
     if (state === "absent") {
       outcomes.push({ relativePath, status: "gone" });
@@ -1683,7 +1773,7 @@ async function inspectUserTierFanout(homeDir, record) {
     health.total++;
     const client2 = clientOfFanoutPath(relativePath);
     if (client2 !== void 0) health.byClient[client2]++;
-    const target = join(homeDir, relativePath);
+    const target = join2(homeDir, relativePath);
     const state = await classifyTarget(target);
     if (state === "absent") {
       health.missing.push(relativePath);
@@ -1694,7 +1784,7 @@ async function inspectUserTierFanout(homeDir, record) {
   return health;
 }
 function isUserTierStore(targetDir) {
-  return resolve(targetDir) === resolve(userTierRoot());
+  return resolve2(targetDir) === resolve2(userTierRoot());
 }
 function resolveInstallScope(targetDir, manifestScope, userFlag) {
   if (userFlag) return { scope: "user", misplacedUserManifest: false };
@@ -1733,7 +1823,7 @@ var WORDMARK = [
 var INDENT = "  ";
 var LOCKUP_WIDTH = INDENT.length + Math.max(...WORDMARK.map((l) => l.length));
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 function isAnimatable() {
   return !!process.stdout.isTTY && process.env["TERM"] !== "dumb" && process.env["CI"] !== "true" && process.env["ARCANE_DISABLE_ANIMATION"] !== "true" && (process.stdout.columns ?? 80) >= LOCKUP_WIDTH;
@@ -1852,7 +1942,7 @@ function printWarning(message) {
 // src/modules/agents.ts
 import { select, checkbox, Separator } from "@inquirer/prompts";
 import { mkdir as mkdir4, writeFile as writeFile6, copyFile as copyFile2 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 import { stringify } from "yaml";
 
 // src/config/agent-roles.ts
@@ -2088,7 +2178,7 @@ async function applyNamingStrategy(strategy, roleIds) {
 
 // src/modules/agent-loader.ts
 import { readFile as readFile4, readdir as readdir3, access as access2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { parse } from "yaml";
 
 // src/modules/agent-schema.ts
@@ -2283,7 +2373,7 @@ function parseYaml2(content, source) {
   }
 }
 async function loadAgentDefinition(agentsDir, id) {
-  const filePath = join2(agentsDir, `${id}.yaml`);
+  const filePath = join3(agentsDir, `${id}.yaml`);
   let content;
   try {
     content = await readFile4(filePath, "utf8");
@@ -2293,10 +2383,10 @@ async function loadAgentDefinition(agentsDir, id) {
   return validateAgentDefinition(parseYaml2(content, filePath), filePath);
 }
 function agentsBaseDir(targetDir, scope = "repo") {
-  return scope === "user" ? targetDir : join2(targetDir, ".arcane");
+  return scope === "user" ? targetDir : join3(targetDir, ".arcane");
 }
 async function loadRoster(targetDir, scope = "repo") {
-  const rosterPath = join2(agentsBaseDir(targetDir, scope), "agents.yaml");
+  const rosterPath = join3(agentsBaseDir(targetDir, scope), "agents.yaml");
   let content;
   try {
     content = await readFile4(rosterPath, "utf8");
@@ -2307,19 +2397,19 @@ async function loadRoster(targetDir, scope = "repo") {
 }
 async function rosterExists(targetDir, scope = "repo") {
   try {
-    await access2(join2(agentsBaseDir(targetDir, scope), "agents.yaml"));
+    await access2(join3(agentsBaseDir(targetDir, scope), "agents.yaml"));
     return true;
   } catch {
     return false;
   }
 }
 function projectAgentsDir(targetDir, scope = "repo") {
-  return join2(agentsBaseDir(targetDir, scope), "agents");
+  return join3(agentsBaseDir(targetDir, scope), "agents");
 }
 
 // src/modules/agent-generator.ts
 import { writeFile as writeFile5, mkdir as mkdir3, readdir as readdir4, readFile as readFile6 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/modules/merger.ts
@@ -2334,7 +2424,7 @@ var MalformedMarkersError = class extends Error {
   }
 };
 async function mergeIntoFile(targetDir, relativePath, content, opts = {}) {
-  validateTargetPath(targetDir, relativePath);
+  validateRealTargetPath(targetDir, relativePath);
   const destPath = path3.resolve(targetDir, relativePath);
   let existing;
   try {
@@ -2394,6 +2484,7 @@ ${MARKER_END}
   return true;
 }
 async function stripMarkerSection(targetDir, relativePath, opts = {}) {
+  validateRealTargetPath(targetDir, relativePath);
   const destPath = path3.resolve(targetDir, relativePath);
   let existing;
   try {
@@ -2532,7 +2623,7 @@ ${userTierRule}`;
 async function loadBranchNamingFragment(assetsDir) {
   try {
     const fragment = await readFile6(
-      join3(assetsDir, ".arcane", "spells", "_fragments", "branch-naming.md"),
+      join4(assetsDir, ".arcane", "spells", "_fragments", "branch-naming.md"),
       "utf8"
     );
     return fragment.trim();
@@ -2577,7 +2668,7 @@ async function syncAgents(targetDir, assetsDir, roster, options = {}) {
   const userAgentFiles = [];
   const unmanagedAgentFiles = [];
   const projectDefs = options.definitionsDir ?? projectAgentsDir(targetDir, userTier ? "user" : "repo");
-  const bundledDefs = join3(assetsDir, "agents");
+  const bundledDefs = join4(assetsDir, "agents");
   const resolved = [];
   for (const entry of roster.roster) {
     let def;
@@ -2606,22 +2697,22 @@ async function syncAgents(targetDir, assetsDir, roster, options = {}) {
     for (const { entry, def, displayName } of resolved) {
       if (!def.clients.openclaw) continue;
       const workspaceName = entry.id === "main" ? "workspace" : `workspace-${entry.id}`;
-      const workspaceDir = join3(openclawRoot, workspaceName);
+      const workspaceDir = join4(openclawRoot, workspaceName);
       try {
         if (!options.dryRun) {
           await mkdir3(workspaceDir, { recursive: true });
           await writeFile5(
-            join3(workspaceDir, "IDENTITY.md"),
+            join4(workspaceDir, "IDENTITY.md"),
             renderIdentity(def, displayName),
             "utf8"
           );
           await writeFile5(
-            join3(workspaceDir, "SOUL.md"),
+            join4(workspaceDir, "SOUL.md"),
             renderSoul(def, displayName),
             "utf8"
           );
           await writeFile5(
-            join3(workspaceDir, "TOOLS.md"),
+            join4(workspaceDir, "TOOLS.md"),
             renderTools(def, displayName),
             "utf8"
           );
@@ -2646,11 +2737,12 @@ async function syncAgents(targetDir, assetsDir, roster, options = {}) {
         }
       }))
     };
-    const generatedDir = join3(targetDir, ".arcane", "generated");
+    const generatedDir = join4(targetDir, ".arcane", "generated");
     if (!options.dryRun) {
+      validateRealTargetDirectory(targetDir, ".arcane/generated");
       await mkdir3(generatedDir, { recursive: true });
       await writeFile5(
-        join3(generatedDir, "openclaw-roster.json"),
+        join4(generatedDir, "openclaw-roster.json"),
         JSON.stringify(patch, null, 2) + "\n",
         "utf8"
       );
@@ -2662,9 +2754,10 @@ async function syncAgents(targetDir, assetsDir, roster, options = {}) {
     synced.push("openclaw-roster.json");
   }
   if (options.copilot !== false) {
-    const agentsDir = join3(targetDir, ".github", "agents");
+    const agentsDir = join4(targetDir, ".github", "agents");
     if (!options.dryRun && !userTier) {
-      await mkdir3(repoOptedOut ? join3(targetDir, ".github") : agentsDir, { recursive: true });
+      validateRealTargetDirectory(targetDir, repoOptedOut ? ".github" : ".github/agents");
+      await mkdir3(repoOptedOut ? join4(targetDir, ".github") : agentsDir, { recursive: true });
     }
     for (const { def, displayName } of resolved) {
       if (!def.clients.copilot?.agent_file) continue;
@@ -2679,7 +2772,8 @@ async function syncAgents(targetDir, assetsDir, roster, options = {}) {
       }
       if (repoOptedOut) continue;
       if (!options.dryRun) {
-        await writeFile5(join3(agentsDir, fileName), content, "utf8");
+        validateRealTargetPath(targetDir, `.github/agents/${fileName}`);
+        await writeFile5(join4(agentsDir, fileName), content, "utf8");
       } else {
         console.log(`  [dry-run] Would write: .github/agents/${fileName}`);
       }
@@ -2783,7 +2877,7 @@ async function performAgentSync(targetDir, assetsDir, roster, options) {
   if (scope === "user") {
     const manifest = await requireUserStore(targetDir);
     const fanout = await syncUserTierFanout({
-      homeDir: dirname2(targetDir),
+      homeDir: dirname3(targetDir),
       storeRoot: targetDir,
       spellIds: [],
       extraFiles: result.userAgentFiles,
@@ -2914,16 +3008,20 @@ All 12 roles across ${allCategories.join(", ")}` : "\nPick individual roles from
     },
     roster: rosterEntries
   };
-  const arcaneDir = join4(baseDir, "agents");
+  const arcaneDir = join5(baseDir, "agents");
   if (!options.dryRun) {
+    if (scope === "repo") {
+      validateRealTargetDirectory(targetDir, ".arcane/agents");
+      validateRealTargetPath(targetDir, ".arcane/agents.yaml");
+    }
     await mkdir4(arcaneDir, { recursive: true });
-    await writeFile6(join4(baseDir, "agents.yaml"), stringify(roster), "utf8");
+    await writeFile6(join5(baseDir, "agents.yaml"), stringify(roster), "utf8");
   } else {
     console.log(`  [dry-run] Would write: ${label2}/agents.yaml`);
   }
   for (const roleId of selectedRoleIds) {
-    const src = join4(assetsDir, "agents", `${roleId}.yaml`);
-    const dest = join4(arcaneDir, `${roleId}.yaml`);
+    const src = join5(assetsDir, "agents", `${roleId}.yaml`);
+    const dest = join5(arcaneDir, `${roleId}.yaml`);
     if (!options.dryRun) {
       try {
         await copyFile2(src, dest);
@@ -3071,7 +3169,7 @@ async function runAgentsList(targetDir, scope = "repo") {
 // src/modules/hub.ts
 import { confirm, select as select2, input as input2 } from "@inquirer/prompts";
 import { readdir as readdir5, writeFile as writeFile7 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/modules/ado-context.ts
 function remoteUrlHost(url) {
@@ -3388,9 +3486,9 @@ function describeFlagPatch(patch) {
   return Object.entries(patch).filter(([field]) => field in FLAG_NAMES).map(([field, value]) => `${field}: ${JSON.stringify(value)}`);
 }
 async function offerRegistryScaffold(targetDir, businessRoot) {
-  const registryPath = join5(targetDir, businessRoot, "registry.json");
+  const registryPath = join6(targetDir, businessRoot, "registry.json");
   if (await fileExists(registryPath)) return;
-  const businessRootPath = join5(targetDir, businessRoot);
+  const businessRootPath = join6(targetDir, businessRoot);
   let ventureDirs;
   try {
     const entries = await readdir5(businessRootPath, { withFileTypes: true });
@@ -3438,26 +3536,6 @@ async function offerRegistryScaffold(targetDir, businessRoot) {
 import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile8, chmod, access as access3, rm as rm4, readdir as readdir6 } from "fs/promises";
 import { constants } from "fs";
 import { join as join7, resolve as resolve3, dirname as dirname4, basename as basename2 } from "path";
-
-// src/modules/real-path.ts
-import { realpathSync } from "fs";
-import { basename, dirname as dirname3, join as join6, resolve as resolve2 } from "path";
-function resolveRealPath(path4) {
-  const missing = [];
-  let existing = path4;
-  for (; ; ) {
-    try {
-      return join6(realpathSync.native(existing), ...missing);
-    } catch {
-      const parent = dirname3(existing);
-      if (parent === existing) return resolve2(path4);
-      missing.unshift(basename(existing));
-      existing = parent;
-    }
-  }
-}
-
-// src/modules/push-safety.ts
 var DISABLED_PUSH_URL = "arcane-push-blocked-run-spell-unblock-push://this-repository";
 var NO_PUSH_URL_MARKER = (remote) => `remote.${remote}.arcaneHadNoPushUrl`;
 var ARCANE_HOOKS_DIR = ".arcane/hooks";
@@ -3577,6 +3655,7 @@ async function installHook(cwd, hookName, body) {
   if (existing !== void 0 && await hookFileMatches(cwd, hookName, body)) {
     return { status: "already-ours" };
   }
+  validateRealTargetDirectory(root, ARCANE_HOOKS_DIR);
   await mkdir5(join7(root, ARCANE_HOOKS_DIR), { recursive: true });
   await writeFile8(hookPath, body, "utf-8");
   await chmod(hookPath, 493);
@@ -3654,6 +3733,7 @@ async function removeHook(cwd, hookName) {
   const root = await repositoryRoot(cwd);
   if (!isArcaneHooksPath(root, existing.value)) return;
   if (existing.scope !== "local" && existing.scope !== "worktree") return;
+  if (findLinkedEscape(root, ARCANE_HOOKS_DIR) !== null) return;
   try {
     await rm4(await hookFilePath(cwd, hookName), { force: true });
   } catch {
@@ -4168,6 +4248,22 @@ async function runInit(options, targetDir, assetsDir, packageVersion) {
   const components = profileComponents.map(
     (component) => componentForSpellScope(component, spell_scope ?? "repo")
   );
+  const plannedFiles = [];
+  for (const component of components) {
+    plannedFiles.push(...component.files);
+    for (const dir of component.directories ?? []) {
+      plannedFiles.push(...await listDirectoryFiles(join8(assetsDir, dir), dir));
+    }
+  }
+  const escapes = findLinkedEscapes(targetDir, plannedFiles);
+  if (escapes.length > 0) {
+    for (const line of describeLinkedEscapes(targetDir, escapes)) console.error(line);
+    console.error(
+      "  \u2717 Init refused: nothing was installed. Arcane writes managed files only inside its target directory: replace each link named above with a directory, then run `spell init` again."
+    );
+    process.exit(1);
+    return;
+  }
   const groups = categorizeComponents(components);
   console.log();
   printSection(`\u{1F4E6} Profile: ${profile}`);
@@ -4518,7 +4614,7 @@ async function runInitUser(options, storeRoot, assetsDir, packageVersion) {
     const fileHashes = {};
     for (const file of component.files) {
       const srcPath = join8(assetsDir, component.sourceOverrides?.[file] ?? file);
-      fileHashes[file] = await copyFile(srcPath, storeRoot, file, { force: options.force });
+      fileHashes[file] = await copyFile(srcPath, storeRoot, file, { force: options.force, followDirectoryLinks: true });
       installedFiles.push(file);
       fileCount++;
     }
@@ -4562,12 +4658,17 @@ async function runInitUser(options, storeRoot, assetsDir, packageVersion) {
   console.log();
 }
 
+// src/commands/add.ts
+import { resolve as resolve4 } from "path";
+
 // src/modules/component-install.ts
 import { readFile as readFile8, stat, writeFile as writeFile9 } from "fs/promises";
-import { join as join9 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 async function planComponentInstall(component, targetDir, assetsDir, opts = {}) {
   const files = [];
   const stateOf = async (file, src) => {
+    const escape = findLinkedEscape(targetDir, dirname6(file));
+    if (escape !== null) return { file, src, state: "linked", escape };
     const dest = join9(targetDir, file);
     if (!await fileExists(dest)) return { file, src, state: "missing" };
     if ((await stat(dest)).isDirectory()) return { file, src, state: "directory" };
@@ -4585,12 +4686,12 @@ async function planComponentInstall(component, targetDir, assetsDir, opts = {})
   }
   const of = (...states) => files.filter((f) => states.includes(f.state));
   if (opts.force) {
-    return { component, files, toCopy: of("missing", "identical", "differs"), kept: [], conflicts: of("directory") };
+    return { component, files, toCopy: of("missing", "identical", "differs"), kept: [], conflicts: of("directory", "linked") };
   }
   if (component.skipExisting) {
-    return { component, files, toCopy: of("missing"), kept: of("identical", "differs", "directory"), conflicts: [] };
+    return { component, files, toCopy: of("missing"), kept: of("identical", "differs", "directory"), conflicts: of("linked") };
   }
-  return { component, files, toCopy: of("missing", "identical"), kept: [], conflicts: of("differs", "directory") };
+  return { component, files, toCopy: of("missing", "identical"), kept: [], conflicts: of("differs", "directory", "linked") };
 }
 async function executeInstallPlan(plan, targetDir, opts = {}) {
   const files = [];
@@ -4631,9 +4732,17 @@ function describeExisting(f) {
 function directoryConflict(plan) {
   return plan.conflicts.find((f) => f.state === "directory");
 }
-function printDryRun2(name, plan, options) {
+function linkedConflict(plan) {
+  return plan.conflicts.find((f) => f.state === "linked");
+}
+function describeLink(f, targetDir) {
+  return `under "${f.escape?.link}", a link to "${f.escape?.resolvesTo}" outside "${resolve4(targetDir)}"`;
+}
+function printDryRun2(name, plan, options, targetDir) {
   for (const f of plan.files) {
-    if (f.state === "missing") {
+    if (f.state === "linked") {
+      console.log(`  [dry-run] Would refuse: ${f.file} (${describeLink(f, targetDir)})`);
+    } else if (f.state === "missing") {
       console.log(`  [dry-run] Would copy: ${f.file}`);
     } else if (f.state === "directory" && !(plan.component.skipExisting && !options.force)) {
       console.log(`  [dry-run] Would refuse: ${f.file} (exists, is a directory) \u2014 remove it first`);
@@ -4647,6 +4756,12 @@ function printDryRun2(name, plan, options) {
       console.log(`  [dry-run] Would refuse: ${f.file} (exists, ${describeExisting(f)}) \u2014 needs --force`);
     }
   }
+  const linked = linkedConflict(plan);
+  if (linked) {
+    console.log(`
+[dry-run] Would refuse component "${name}": "${linked.file}" is ${describeLink(linked, targetDir)}. Replace the link with a directory first.`);
+    return;
+  }
   const dir = directoryConflict(plan);
   if (dir) {
     console.log(`
@@ -4683,9 +4798,16 @@ async function addOne(name, options, targetDir, assetsDir, packageVersion) {
   }
   const plan = await planComponentInstall(component, targetDir, assetsDir, { force: options.force });
   if (options.dryRun) {
-    printDryRun2(name, plan, options);
+    printDryRun2(name, plan, options, targetDir);
     return plan.conflicts.length > 0 ? "failed" : "added";
   }
+  const linked = linkedConflict(plan);
+  if (linked) {
+    console.error(
+      `Cannot add "${name}": "${linked.file}" is ${describeLink(linked, targetDir)}. Nothing was written. Replace the link with a directory, then run spell add again.`
+    );
+    return "failed";
+  }
   const dir = directoryConflict(plan);
   if (dir) {
     console.error(
@@ -4752,7 +4874,7 @@ async function runAdd(names, options, targetDir, assetsDir, packageVersion) {
 }
 
 // src/commands/update.ts
-import { dirname as dirname6, join as join11 } from "path";
+import { dirname as dirname7, join as join11 } from "path";
 import { readFile as readFile9 } from "fs/promises";
 
 // src/modules/merge3.ts
@@ -4984,6 +5106,7 @@ function formatRegistryChanges(changes) {
 }
 
 // src/modules/update-installs.ts
+import { resolve as resolve5 } from "path";
 import { checkbox as checkbox2 } from "@inquirer/prompts";
 function offerableNewComponents(newlyAvailable, missingRequires) {
   return newlyAvailable.filter(
@@ -5012,7 +5135,7 @@ async function planUpdateInstalls(args) {
     if (component.files.length === 0) continue;
     const plan = await planComponentInstall(component, args.targetDir, args.assetsDir, {});
     if (plan.conflicts.length > 0) {
-      leftAlone.push({ name, kind: "prerequisite", reason: conflictReason(plan) });
+      leftAlone.push({ name, kind: "prerequisite", reason: conflictReason(plan, args.targetDir) });
       continue;
     }
     items.push({ plan, kind: "prerequisite", requiredBy });
@@ -5022,14 +5145,18 @@ async function planUpdateInstalls(args) {
     if (component.initOnly || component.files.length === 0) continue;
     const plan = await planComponentInstall(component, args.targetDir, args.assetsDir, {});
     if (plan.conflicts.length > 0) {
-      leftAlone.push({ name: candidate.name, kind: "new", reason: conflictReason(plan) });
+      leftAlone.push({ name: candidate.name, kind: "new", reason: conflictReason(plan, args.targetDir) });
       continue;
     }
     items.push({ plan, kind: "new", requiredBy: [] });
   }
   return { items, leftAlone };
 }
-function conflictReason(plan) {
+function conflictReason(plan, targetDir) {
+  const linked = plan.conflicts.find((f) => f.state === "linked");
+  if (linked) {
+    return `${linked.file} is under "${linked.escape?.link}", a link to "${linked.escape?.resolvesTo}" outside "${resolve5(targetDir)}", and update writes nothing there`;
+  }
   const first = plan.conflicts[0];
   if (first.state === "directory") return `${first.file} is a directory, which update does not replace`;
   const more = plan.conflicts.length > 1 ? ` (and ${plan.conflicts.length - 1} more)` : "";
@@ -5182,13 +5309,40 @@ function moveComponentFiles(components, present = () => true) {
   }
   return out;
 }
-async function resolveOrphan(targetDir, file, recordedHash, prune) {
+async function plannedUpdateWrites(installed, scope, spellScope, assetsDir) {
+  const files = [];
+  for (const entry of migrateLegacyComponents(installed).components) {
+    let component;
+    try {
+      component = componentForSpellScope(
+        componentForScope(getComponent(entry.name), scope),
+        scope === "repo" ? spellScope : "repo"
+      );
+    } catch (err) {
+      if (err instanceof ComponentNotFoundError) continue;
+      throw err;
+    }
+    files.push(...component.files);
+    for (const dir of component.directories ?? []) {
+      files.push(...await listDirectoryFiles(join11(assetsDir, dir), dir));
+    }
+  }
+  return files;
+}
+async function resolveOrphan(targetDir, file, recordedHash, prune, followDirectoryLinks = false) {
   try {
     validateTargetPath(targetDir, file);
   } catch {
     console.log(`  ! Refused (path escapes the target directory): ${file}`);
     return "reported";
   }
+  const escape = followDirectoryLinks ? null : findLinkedEscape(targetDir, dirname7(file));
+  if (escape !== null) {
+    console.log(
+      `  ! Refused (under "${escape.link}", a link to "${escape.resolvesTo}" outside the target directory): ${file}`
+    );
+    return "reported";
+  }
   const filePath = join11(targetDir, file);
   if (!await fileExists(filePath)) return "not-found";
   if (!prune) return "reported";
@@ -5200,8 +5354,8 @@ async function resolveOrphan(targetDir, file, recordedHash, prune) {
       );
       return "reported";
     }
-    await removeWithin(targetDir, file);
-    await removeEmptyAncestors(targetDir, file);
+    await removeWithin(targetDir, file, { followDirectoryLinks });
+    await removeEmptyAncestors(targetDir, file, { followDirectoryLinks });
     console.log(`  Pruned orphaned file (no recorded hash; git shows it ${evidence.detail}): ${file}`);
     return "pruned";
   }
@@ -5209,8 +5363,8 @@ async function resolveOrphan(targetDir, file, recordedHash, prune) {
     console.log(`  ! Orphaned but edited since install \u2014 not pruning: ${file}`);
     return "reported";
   }
-  await removeWithin(targetDir, file);
-  await removeEmptyAncestors(targetDir, file);
+  await removeWithin(targetDir, file, { followDirectoryLinks });
+  await removeEmptyAncestors(targetDir, file, { followDirectoryLinks });
   console.log(`  Pruned orphaned file: ${file}`);
   return "pruned";
 }
@@ -5346,7 +5500,7 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
   const answered = { ...manifest, ...flagPatch };
   const spellScope = effectiveSpellScope(manifest);
   const readopted = findReadoptedSpellComponents(manifest.components, scope, spellScope);
-  const homeDir = dirname6(targetDir);
+  const homeDir = dirname7(targetDir);
   const tierGate = await missingTierWarning(scope, spellScope);
   if (tierGate.length > 0) {
     for (const line of tierGate) console.error(line);
@@ -5388,6 +5542,18 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
   }
   const linkTracked = scope === "repo" ? await listSymlinkTrackedPaths(targetDir) : /* @__PURE__ */ new Set();
   const conversions = [];
+  const followDirectoryLinks = scope === "user";
+  const linkedEscapes = followDirectoryLinks || manifest.components.length === 0 ? [] : findLinkedEscapes(targetDir, await plannedUpdateWrites(manifest.components, scope, spellScope, assetsDir));
+  const refusedForLinks = () => {
+    if (linkedEscapes.length === 0) return false;
+    for (const line of describeLinkedEscapes(targetDir, linkedEscapes)) console.error(line);
+    console.error(
+      "  \u2717 Update refused: nothing was written. Arcane writes and deletes managed files only inside its target directory: replace each link named above with a directory, then run `spell update` again."
+    );
+    process.exit(1);
+    return true;
+  };
+  if (manifest.version !== packageVersion && refusedForLinks()) return;
   const registryChanges = {
     retired: findTrackedRetirements(manifest.components),
     ...scope === "repo" ? {
@@ -5466,6 +5632,7 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
       }
       return;
     }
+    if (refusedForLinks()) return;
     sameVersionRestore = true;
     const prefix = options.dryRun ? "[dry-run] " : "";
     if (missing.length > 0) {
@@ -5528,7 +5695,8 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
             targetDir,
             file,
             recordedHash,
-            Boolean(options.prune) && !options.dryRun
+            Boolean(options.prune) && !options.dryRun,
+            followDirectoryLinks
           );
           orphanReport.push({ file, status });
           if (status === "reported") stillTracked.push(file);
@@ -5618,7 +5786,7 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
               readFile9(srcPath, "utf-8")
             ]);
             const result = merge3(oldVendorContent, currentContent, newContent);
-            await writeManagedFile(targetDir, file, result.content, { linkTracked, conversions });
+            await writeManagedFile(targetDir, file, result.content, { linkTracked, conversions, followDirectoryLinks });
             fileHashes[file] = await hashFile(srcPath);
             if (result.hasConflict) {
               conflictedFiles.push(file);
@@ -5630,7 +5798,12 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
           }
         }
         if (!handled) {
-          fileHashes[file] = await copyFile(srcPath, targetDir, file, { force: true, linkTracked, conversions });
+          fileHashes[file] = await copyFile(srcPath, targetDir, file, {
+            force: true,
+            linkTracked,
+            conversions,
+            followDirectoryLinks
+          });
           if (linkShape === "path-body") conversions.push({ file, shape: "path-body" });
           if (sameVersionRestore) console.log(`  Restored missing: ${file}`);
         }
@@ -5645,7 +5818,12 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
       if (options.dryRun) {
         console.log(`  [dry-run] Would update directory: ${dir}/`);
       } else {
-        const copied = await copyDirectory(srcDirPath, targetDir, dir, { force: true, linkTracked, conversions });
+        const copied = await copyDirectory(srcDirPath, targetDir, dir, {
+          force: true,
+          linkTracked,
+          conversions,
+          followDirectoryLinks
+        });
         for (const { path: copiedPath, hash } of copied) {
           updatedFiles.push(copiedPath);
           fileHashes[copiedPath] = hash;
@@ -5678,7 +5856,8 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
       targetDir,
       file,
       recordedHash,
-      Boolean(options.prune) && !options.dryRun
+      Boolean(options.prune) && !options.dryRun,
+      followDirectoryLinks
     );
     orphanReport.push({ file, status });
     if (status !== "reported") continue;
@@ -5816,11 +5995,11 @@ ${verb} ${orphansToReport.length} orphaned file(s) (tracked before this update,
 }
 
 // src/commands/status.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/modules/version-check.ts
 import { readFile as readFile10, writeFile as writeFile10, mkdir as mkdir6 } from "fs/promises";
-import { dirname as dirname7, join as join12 } from "path";
+import { dirname as dirname8, join as join12 } from "path";
 import { homedir as homedir3 } from "os";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -5849,7 +6028,7 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, latest) {
-  await mkdir6(dirname7(cachePath), { recursive: true });
+  await mkdir6(dirname8(cachePath), { recursive: true });
   const entry = { latest, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await writeFile10(cachePath, JSON.stringify(entry, null, 2), "utf-8");
 }
@@ -5990,7 +6169,7 @@ async function runStatus(targetDir, packageVersion, options = {}) {
   console.log("");
   if (scope === "user") {
     console.log(`  Scope: user \u2014 ${targetDir}`);
-    const health = await inspectUserTierFanout(dirname8(targetDir), manifest.fanout);
+    const health = await inspectUserTierFanout(dirname9(targetDir), manifest.fanout);
     console.log(
       `  Client files: ${health.total} (${health.byClient.codex} ${FANOUT_CLIENT_LABELS.codex}, ${health.byClient.claude} ${FANOUT_CLIENT_LABELS.claude})`
     );
@@ -6053,7 +6232,7 @@ async function runStatus(targetDir, packageVersion, options = {}) {
 
 // src/commands/uninstall.ts
 import { rm as rm5 } from "fs/promises";
-import { dirname as dirname9, join as join13 } from "path";
+import { dirname as dirname10, join as join13, resolve as resolve6 } from "path";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function runUninstall(options, targetDir) {
   let manifest;
@@ -6124,35 +6303,48 @@ Run \`spell unblock-push\` first (interactive), then uninstall.`
     }
   }
   let removed = 0;
+  let leftBehindLinks = 0;
+  const skip = (path4, err) => {
+    if (err instanceof LinkedDirectoryError) leftBehindLinks++;
+    console.log(`  ! Skipped ${path4}: ${skipReason(err, targetDir)}`);
+  };
   for (const component of manifest.components) {
     for (const file of component.files) {
       try {
         await removeWithin(targetDir, file);
         removed++;
       } catch (err) {
-        console.log(
-          `  ! Skipped ${file}: ${err instanceof Error ? err.message : String(err)}`
-        );
+        skip(file, err);
       }
     }
   }
   await rm5(join13(targetDir, ".arcane.json"), { force: true });
-  const agentDirs = [
+  const agentOutputs = [
     ".github/agents",
     ".arcane/agents",
-    ".arcane/generated"
+    ".arcane/generated",
+    ".arcane/agents.yaml"
   ];
-  for (const dir of agentDirs) {
-    await rm5(join13(targetDir, dir), { recursive: true, force: true });
+  for (const output of agentOutputs) {
+    try {
+      validateRealTargetPath(targetDir, output);
+    } catch (err) {
+      if (await fileExists(join13(targetDir, output))) skip(output, err);
+      continue;
+    }
+    await rm5(join13(targetDir, output), { recursive: true, force: true });
   }
-  await rm5(join13(targetDir, ".arcane/agents.yaml"), { force: true });
   const markerFiles = [
     "CLAUDE.md",
     "AGENTS.md",
     ".github/copilot-instructions.md"
   ];
   for (const file of markerFiles) {
-    await stripMarkerSection(targetDir, file, { dryRun: false });
+    try {
+      await stripMarkerSection(targetDir, file, { dryRun: false });
+    } catch (err) {
+      skip(file, err);
+    }
   }
   try {
     await removeSecretsPrecommitHook(targetDir);
@@ -6160,9 +6352,20 @@ Run \`spell unblock-push\` first (interactive), then uninstall.`
   }
   console.log(`
 \u2713 Uninstalled \u2014 ${removed} files removed.`);
+  if (leftBehindLinks > 0) {
+    console.log(
+      `  ! Left ${leftBehindLinks} path(s) where a link outside "${resolve6(targetDir)}" points (named above): Arcane deletes nothing outside it.`
+    );
+  }
+}
+function skipReason(err, targetDir) {
+  if (err instanceof LinkedDirectoryError) {
+    return `it is under "${err.escape.link}", a link to "${err.escape.resolvesTo}" outside "${resolve6(targetDir)}"; nothing there is deleted.`;
+  }
+  return err instanceof Error ? err.message : String(err);
 }
 async function uninstallUserTier(options, storeRoot, manifest) {
-  const homeDir = dirname9(storeRoot);
+  const homeDir = dirname10(storeRoot);
   const storeFiles = manifest.components.flatMap((c) => c.files);
   const recordedCount = Object.keys(manifest.fanout ?? {}).length;
   if (options.dryRun) {
@@ -6201,7 +6404,7 @@ async function uninstallUserTier(options, storeRoot, manifest) {
   let removed = 0;
   for (const file of storeFiles) {
     try {
-      await removeWithin(storeRoot, file);
+      await removeWithin(storeRoot, file, { followDirectoryLinks: true });
       removed++;
     } catch (err) {
       console.log(`  ! Skipped ${file}: ${err instanceof Error ? err.message : String(err)}`);
@@ -6223,7 +6426,7 @@ async function uninstallUserTier(options, storeRoot, manifest) {
 
 // src/commands/doctor.ts
 import { access as access4, readdir as readdir9, readFile as readFile13, mkdir as mkdir7, copyFile as fsCopyFile } from "fs/promises";
-import { join as join16, dirname as dirname10 } from "path";
+import { join as join16, dirname as dirname11, resolve as resolve7 } from "path";
 
 // src/config/incidents.ts
 var INCIDENT_QUEUE = [
@@ -6370,7 +6573,7 @@ import { existsSync, readFileSync } from "fs";
 import { win32 } from "path";
 var EXTERNAL_CLI_TIMEOUT_MS = 1e4;
 function execFileWithTimeout(file, args, timeoutMs, options = {}) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = execFile2(
       file,
       args,
@@ -6386,7 +6589,7 @@ function execFileWithTimeout(file, args, timeoutMs, options = {}) {
           reject(error);
           return;
         }
-        resolve6({ stdout, stderr });
+        resolve10({ stdout, stderr });
       }
     );
     child.stdin?.end();
@@ -6910,8 +7113,15 @@ async function fixSessionContinuity(targetDir, assetsDir) {
     try {
       await access4(destPath);
     } catch {
+      const escape = findLinkedEscape(targetDir, dirname11(file));
+      if (escape !== null) {
+        console.log(
+          `    ! Not created: ${file} \u2014 it is under "${escape.link}", a link to "${escape.resolvesTo}" outside "${resolve7(targetDir)}".`
+        );
+        continue;
+      }
       const srcPath = join16(assetsDir, file);
-      await mkdir7(dirname10(destPath), { recursive: true });
+      await mkdir7(dirname11(destPath), { recursive: true });
       await fsCopyFile(srcPath, destPath);
       created.push(file);
     }
@@ -7459,10 +7669,17 @@ async function runDoctor(targetDir, options = {}, assetsDir) {
   if (options.fix && hasMissingSession && assetsDir) {
     console.log("  \u{1F527} Fixing missing session continuity files...\n");
     const created = await fixSessionContinuity(targetDir, assetsDir);
-    if (created.length > 0) {
-      for (const file of created) {
-        console.log(`    \u2713 Created: ${file}`);
-      }
+    for (const file of created) {
+      console.log(`    \u2713 Created: ${file}`);
+    }
+    const stillMissing = (await checkSessionContinuity(targetDir)).filter((r) => !r.passed).length;
+    if (stillMissing > 0) {
+      console.log(
+        `
+  ${created.length} file(s) created; ${stillMissing} still missing (named above). Repo is not close-session-ready yet.
+`
+      );
+    } else if (created.length > 0) {
       console.log(`
   ${created.length} file(s) created. Repo is now close-session-ready.
 `);
@@ -7657,7 +7874,7 @@ async function runWardCli(targetDir, options = {}, exclusions = []) {
 }
 
 // src/commands/unblock-push.ts
-import { basename as basename3, resolve as resolve4 } from "path";
+import { basename as basename3, resolve as resolve8 } from "path";
 import { input as input4 } from "@inquirer/prompts";
 async function runUnblockPush(targetDir) {
   let manifest;
@@ -7689,7 +7906,7 @@ async function runUnblockPush(targetDir) {
     process.exit(1);
     return;
   }
-  const repoName = basename3(resolve4(targetDir));
+  const repoName = basename3(resolve8(targetDir));
   if (repoName === "") {
     console.error(
       "Could not determine a repository name to confirm against (is this repository at a filesystem root?). Refusing to unblock."
@@ -7736,7 +7953,7 @@ Name did not match ("${typed.trim()}" \u2260 "${repoName}"). Nothing changed.`);
   }
   if (hookStillOn) {
     printWarning(
-      "The pre-push hook is still in force. Arcane did not remove it because `core.hooksPath` is not one it owns, or could not be read. Check `git config --show-scope --get core.hooksPath`."
+      "The pre-push hook is still in force. Arcane did not remove it because `core.hooksPath` is not one it owns, could not be read, or names a directory that a link takes outside this repository. Check `git config --show-scope --get core.hooksPath`."
     );
   }
   if (failed.length > 0) {
@@ -8107,9 +8324,9 @@ async function browserLogin(config, options) {
   const state = client.randomState();
   const nonce = client.randomNonce();
   const server = createServer();
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve10, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve6());
+    server.listen(0, "127.0.0.1", () => resolve10());
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
@@ -8135,7 +8352,7 @@ async function browserLogin(config, options) {
     server.closeAllConnections?.();
     server.close();
   };
-  const tokens = new Promise((resolve6, reject) => {
+  const tokens = new Promise((resolve10, reject) => {
     server.on("request", (req, res) => {
       const url = new URL(req.url ?? "/", redirectUri);
       if (RESULT_PATHS.has(url.pathname)) {
@@ -8146,7 +8363,7 @@ async function browserLogin(config, options) {
         const served = browserResult;
         const page = pages[served.kind];
         const settle = () => {
-          if (served.kind === "success") resolve6(served.result);
+          if (served.kind === "success") resolve10(served.result);
           else reject(served.error);
         };
         res.once("finish", settle).once("close", settle);
@@ -8175,7 +8392,7 @@ async function browserLogin(config, options) {
         }).end();
         if (result.kind === "success") {
           if (timer) clearTimeout(timer);
-          timer = setTimeout(() => resolve6(result.result), Math.min(timeoutMs, 5e3));
+          timer = setTimeout(() => resolve10(result.result), Math.min(timeoutMs, 5e3));
         }
       };
       const errorCode = url.searchParams.get("error");
@@ -8227,12 +8444,12 @@ async function refreshSession(config, refreshToken, scopes) {
 }
 function openInDefaultBrowser(url) {
   const [command, args] = process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
-  return new Promise((resolve6) => {
+  return new Promise((resolve10) => {
     try {
-      const child = execFile3(command, args, { windowsHide: true }, (error) => resolve6(!error));
-      child.on("error", () => resolve6(false));
+      const child = execFile3(command, args, { windowsHide: true }, (error) => resolve10(!error));
+      child.on("error", () => resolve10(false));
     } catch {
-      resolve6(false);
+      resolve10(false);
     }
   });
 }
@@ -8241,7 +8458,7 @@ function openInDefaultBrowser(url) {
 import { execFileSync } from "child_process";
 import { mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync, existsSync as existsSync2 } from "fs";
 import { userInfo } from "os";
-import { dirname as dirname11, join as join19 } from "path";
+import { dirname as dirname12, join as join19 } from "path";
 
 // src/modules/keychain-backend.ts
 import { createRequire as createRequire2 } from "module";
@@ -8330,7 +8547,7 @@ var FileSecretBackend = class {
       rmSync(this.filePath, { force: true });
       return;
     }
-    mkdirSync(dirname11(this.filePath), { recursive: true });
+    mkdirSync(dirname12(this.filePath), { recursive: true });
     const tmp = `${this.filePath}.${process.pid}.tmp`;
     writeFileSync(tmp, JSON.stringify(entries), { encoding: "utf8", mode: 384 });
     try {
@@ -8647,7 +8864,7 @@ import { join as join22 } from "path";
 
 // src/modules/show-report/generate.ts
 import { mkdir as mkdir8, readdir as readdir11, readFile as readFile18, writeFile as writeFile11 } from "fs/promises";
-import { basename as basename4, dirname as dirname12, isAbsolute, join as join21, relative as relative3, resolve as resolve5 } from "path";
+import { basename as basename4, dirname as dirname13, isAbsolute, join as join21, relative as relative3, resolve as resolve9 } from "path";
 
 // src/modules/show-report/model.ts
 import { readFile as readFile17 } from "fs/promises";
@@ -9234,7 +9451,7 @@ async function programFromPlan(rootDir, slug, planRelPath) {
     program: {
       slug,
       planRelPath,
-      queueRelPath: toPosix(join21(dirname12(planRelPath), "OPERATOR-QUEUE.md")),
+      queueRelPath: toPosix(join21(dirname13(planRelPath), "OPERATOR-QUEUE.md")),
       ledgerProgramName: programNameFromTitle(frontmatter.title ?? slug)
     }
   };
@@ -9258,9 +9475,9 @@ async function discoverPrograms(rootDir) {
   return { programs, skipped };
 }
 async function programFromPlanPath(rootDir, planPath) {
-  const planAbs = isAbsolute(planPath) ? planPath : resolve5(rootDir, planPath);
+  const planAbs = isAbsolute(planPath) ? planPath : resolve9(rootDir, planPath);
   const planRelPath = toPosix(relative3(rootDir, planAbs));
-  return programFromPlan(rootDir, basename4(dirname12(planAbs)), planRelPath);
+  return programFromPlan(rootDir, basename4(dirname13(planAbs)), planRelPath);
 }
 function normalizeLineEndings2(content) {
   return content.replace(/\r\n?/g, "\n");
@@ -9305,7 +9522,7 @@ async function runReportGeneration(options) {
     if (!generated.themeApplied) themeSkipped.push(program2.slug);
     const missing = JSON.parse(generated.json).sections.flatMap((section) => section.rows).filter((row) => row.descriptionState === "unwritten").map((row) => row.id);
     if (missing.length > 0) unwritten.push({ slug: program2.slug, ids: missing });
-    const outAbs = options.outDir ? isAbsolute(options.outDir) ? options.outDir : resolve5(options.rootDir, options.outDir) : resolve5(options.rootDir, dirname12(program2.planRelPath));
+    const outAbs = options.outDir ? isAbsolute(options.outDir) ? options.outDir : resolve9(options.rootDir, options.outDir) : resolve9(options.rootDir, dirname13(program2.planRelPath));
     const outRel = toPosix(relative3(options.rootDir, outAbs));
     const outputs = [
       [`${outRel}/show-report.json`, generated.json],
@@ -9405,7 +9622,7 @@ async function runReport(targetDir, options = {}, assetsDir) {
 import { realpathSync as realpathSync2 } from "fs";
 var require3 = createRequire3(import.meta.url);
 var pkg = require3("../package.json");
-var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join23(dirname13(fileURLToPath(import.meta.url)), "assets");
+var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join23(dirname14(fileURLToPath(import.meta.url)), "assets");
 var program = new Command();
 var USER_FLAG_DESCRIPTION = "Operate on the per-user tier at ~/.arcane \u2014 spells shared by every repository on this machine, fanned out to ~/.agents/skills (Codex, Copilot) and ~/.claude/commands (Claude Code)";
 var USER_TIER_AGENTS_DESCRIPTION = "Operate on the per-user tier at ~/.arcane \u2014 one agent roster shared by every repository on this machine, rendered to ~/.copilot/agents (VS Code agent modes)";