facult 2.3.1 → 2.5.0

package/src/manage.ts

@@ -32,7 +32,7 @@ import {
   type SkillEntry,
 } from "./index-builder";
 import {
-  facultGeneratedStateDir,
+  facultMachineStateDir,
   facultRootDir,
   legacyFacultStateDirForRoot,
   projectRootFromAiRoot,
@@ -44,6 +44,7 @@ export interface ManagedToolState {
   skillsDir?: string;
   mcpConfig?: string;
   agentsDir?: string;
+  automationDir?: string;
   toolHome?: string;
   globalAgentsPath?: string;
   globalAgentsOverridePath?: string;
@@ -75,6 +76,7 @@ export interface ToolPaths {
   skillsDir?: string;
   mcpConfig?: string;
   agentsDir?: string;
+  automationDir?: string;
   toolHome?: string;
   rulesDir?: string;
   toolConfig?: string;
@@ -163,6 +165,7 @@ function defaultToolPaths(
       skillsDir: toolBase(".codex", "skills"),
       mcpConfig: toolBase(".codex", "mcp.json"),
       agentsDir: toolBase(".codex", "agents"),
+      automationDir: homePath(home, ".codex", "automations"),
       toolHome: toolBase(".codex"),
       rulesDir: toolBase(".codex", "rules"),
       toolConfig: toolBase(".codex", "config.toml"),
@@ -200,6 +203,19 @@ function defaultToolPaths(
       skillsDir: toolBase(".antigravity", "skills"),
       mcpConfig: toolBase(".antigravity", "mcp.json"),
     },
+    factory: {
+      tool: "factory",
+      skillsDir: projectRoot
+        ? join(projectRoot, ".factory", "skills")
+        : homePath(home, ".factory", "skills"),
+      mcpConfig: projectRoot
+        ? join(projectRoot, ".factory", "mcp.json")
+        : homePath(home, ".factory", "mcp.json"),
+      agentsDir: projectRoot
+        ? join(projectRoot, ".factory", "droids")
+        : homePath(home, ".factory", "droids"),
+      toolHome: projectRoot ? undefined : homePath(home, ".factory"),
+    },
   };
 
   const adapterDefaults = (tool: string): ToolPaths | null => {
@@ -293,7 +309,7 @@ export function managedStatePathForRoot(
   home: string = homedir(),
   rootDir?: string
 ): string {
-  return join(facultGeneratedStateDir({ home, rootDir }), "managed.json");
+  return join(facultMachineStateDir(home, rootDir), "managed.json");
 }
 
 function legacyManagedStatePathForRoot(
@@ -336,7 +352,7 @@ export async function saveManagedState(
   home: string = homedir(),
   rootDir?: string
 ) {
-  const dir = facultGeneratedStateDir({ home, rootDir });
+  const dir = facultMachineStateDir(home, rootDir);
   await ensureDir(dir);
   await Bun.write(
     managedStatePathForRoot(home, rootDir),
@@ -433,6 +449,167 @@ async function loadCanonicalAgents(
   return await loadAgentsFromRoot(homePath(rootDir, "agents"));
 }
 
+function managedAgentFileExtension(tool: string): string {
+  return getAdapter(tool)?.agentFileExtension ?? ".toml";
+}
+
+async function renderManagedAgentFile(args: {
+  agent: { name: string; sourcePath: string; raw: string };
+  homeDir: string;
+  rootDir: string;
+  tool: string;
+  targetPath: string;
+}): Promise<string> {
+  const adapter = getAdapter(args.tool);
+  if (adapter?.renderAgent) {
+    return await adapter.renderAgent({
+      raw: args.agent.raw,
+      homeDir: args.homeDir,
+      rootDir: args.rootDir,
+      projectRoot:
+        projectRootFromAiRoot(args.rootDir, args.homeDir) ?? undefined,
+      tool: args.tool,
+      targetPath: args.targetPath,
+    });
+  }
+
+  return await renderCanonicalText(args.agent.raw, {
+    homeDir: args.homeDir,
+    rootDir: args.rootDir,
+    projectRoot: projectRootFromAiRoot(args.rootDir, args.homeDir) ?? undefined,
+    targetTool: args.tool,
+    targetPath: args.targetPath,
+  });
+}
+
+async function loadManagedAgentsFromTool(args: {
+  tool: string;
+  agentsDir: string;
+}): Promise<{ name: string; sourcePath: string; raw: string }[]> {
+  const adapter = getAdapter(args.tool);
+  if (!adapter?.parseManagedAgentFile) {
+    return await loadAgentsFromRoot(args.agentsDir);
+  }
+
+  const extension = managedAgentFileExtension(args.tool);
+  const entries = await readdir(args.agentsDir, { withFileTypes: true }).catch(
+    () => [] as import("node:fs").Dirent[]
+  );
+  const out: { name: string; sourcePath: string; raw: string }[] = [];
+
+  for (const entry of entries) {
+    if (!(entry.isFile() && entry.name.endsWith(extension))) {
+      continue;
+    }
+    const sourcePath = join(args.agentsDir, entry.name);
+    const parsed = await adapter.parseManagedAgentFile(sourcePath);
+    if (!parsed) {
+      continue;
+    }
+    out.push(parsed);
+  }
+
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+interface AutomationEntry {
+  name: string;
+  sourceDir: string;
+  files: Map<string, string>;
+}
+
+async function listRelativeFiles(root: string): Promise<string[]> {
+  const out: string[] = [];
+
+  async function visit(currentDir: string, prefix = ""): Promise<void> {
+    const entries = await readdir(currentDir, { withFileTypes: true }).catch(
+      () => [] as import("node:fs").Dirent[]
+    );
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const relPath = prefix ? join(prefix, entry.name) : entry.name;
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(fullPath, relPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        out.push(relPath);
+      }
+    }
+  }
+
+  await visit(root);
+  return out.sort();
+}
+
+async function loadAutomationEntries(
+  automationsRoot: string
+): Promise<AutomationEntry[]> {
+  const entries = await readdir(automationsRoot, { withFileTypes: true }).catch(
+    () => [] as import("node:fs").Dirent[]
+  );
+  const out: AutomationEntry[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    const sourceDir = join(automationsRoot, entry.name);
+    const relativeFiles = await listRelativeFiles(sourceDir);
+    const files = new Map<string, string>();
+    for (const relPath of relativeFiles) {
+      const raw = await readTextIfExists(join(sourceDir, relPath));
+      if (raw == null) {
+        continue;
+      }
+      files.set(relPath, raw);
+    }
+    if (!files.has("automation.toml")) {
+      continue;
+    }
+    out.push({
+      name: entry.name,
+      sourceDir,
+      files,
+    });
+  }
+
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function loadCanonicalAutomations(
+  rootDir: string
+): Promise<AutomationEntry[]> {
+  return await loadAutomationEntries(join(rootDir, "automations"));
+}
+
+function automationEntriesEqual(
+  left: AutomationEntry,
+  right: AutomationEntry
+): boolean {
+  if (left.files.size !== right.files.size) {
+    return false;
+  }
+  for (const [relPath, leftRaw] of left.files.entries()) {
+    if (right.files.get(relPath) !== leftRaw) {
+      return false;
+    }
+  }
+  return true;
+}
+
+async function canonicalAutomationsExist(rootDir: string): Promise<boolean> {
+  try {
+    const automations = await loadCanonicalAutomations(rootDir);
+    return automations.length > 0;
+  } catch {
+    return false;
+  }
+}
+
 async function loadMergedIndex(
   homeDir: string,
   rootDir: string
@@ -536,14 +713,15 @@ async function planAgentFileChanges({
   const contents = new Map<string, string>();
   const sources = new Map<string, string>();
   const desiredPaths = new Set<string>();
+  const extension = managedAgentFileExtension(tool);
 
   for (const agent of agents) {
-    const target = homePath(agentsDir, `${agent.name}.toml`);
-    const rendered = await renderCanonicalText(agent.raw, {
+    const target = homePath(agentsDir, `${agent.name}${extension}`);
+    const rendered = await renderManagedAgentFile({
+      agent,
       homeDir,
       rootDir,
-      projectRoot: projectRootFromAiRoot(rootDir, homeDir) ?? undefined,
-      targetTool: tool,
+      tool,
       targetPath: target,
     });
     desiredPaths.add(target);
@@ -558,7 +736,7 @@ async function planAgentFileChanges({
   const remove = new Set<string>();
 
   for (const entry of existing) {
-    if (!(entry.isFile() && entry.name.endsWith(".toml"))) {
+    if (!(entry.isFile() && entry.name.endsWith(extension))) {
       continue;
     }
     const p = homePath(agentsDir, entry.name);
@@ -624,6 +802,58 @@ async function syncAgentFiles({
   return { add: plan.add, remove: plan.remove };
 }
 
+async function planAutomationFileChanges(args: {
+  automationDir: string;
+  rootDir: string;
+  previouslyManagedTargets?: string[];
+}): Promise<{
+  add: string[];
+  remove: string[];
+  contents: Map<string, string>;
+  sources: Map<string, string>;
+}> {
+  const automations = await loadCanonicalAutomations(args.rootDir);
+  const contents = new Map<string, string>();
+  const sources = new Map<string, string>();
+  const desiredPaths = new Set<string>();
+
+  for (const automation of automations) {
+    for (const [relPath, raw] of automation.files.entries()) {
+      const targetPath = join(args.automationDir, automation.name, relPath);
+      const sourcePath = join(automation.sourceDir, relPath);
+      desiredPaths.add(targetPath);
+      contents.set(targetPath, raw);
+      sources.set(targetPath, sourcePath);
+    }
+  }
+
+  const add = new Set<string>();
+  for (const targetPath of desiredPaths) {
+    const current = await readTextIfExists(targetPath);
+    const desired = contents.get(targetPath);
+    if (desired != null && current !== desired) {
+      add.add(targetPath);
+    }
+  }
+
+  const remove = Array.from(
+    new Set(
+      (args.previouslyManagedTargets ?? []).filter(
+        (targetPath) =>
+          targetPath.startsWith(join(args.automationDir, "")) &&
+          !desiredPaths.has(targetPath)
+      )
+    )
+  ).sort();
+
+  return {
+    add: Array.from(add).sort(),
+    remove,
+    contents,
+    sources,
+  };
+}
+
 async function listSkillDirs(skillsRoot: string): Promise<string[]> {
   try {
     const entries = await readdir(skillsRoot, { withFileTypes: true });
@@ -945,6 +1175,7 @@ interface ExistingManagedItem {
   kind:
     | "skill"
     | "agent"
+    | "automation"
     | "global-doc"
     | "rule"
     | "tool-config"
@@ -1060,11 +1291,15 @@ function logManagedImportPlan(tool: string, plan: ExistingManagedImportPlan) {
 }
 
 async function planExistingToolAgentAdoption(args: {
+  tool: string;
   rootDir: string;
   agentsDir: string;
 }): Promise<ExistingManagedImportPlan> {
   const plan = emptyManagedImportPlan();
-  const agents = await loadAgentsFromRoot(args.agentsDir);
+  const agents = await loadManagedAgentsFromTool({
+    tool: args.tool,
+    agentsDir: args.agentsDir,
+  });
   for (const agent of agents) {
     const canonicalPath = join(
       args.rootDir,
@@ -1091,12 +1326,16 @@ async function planExistingToolAgentAdoption(args: {
 }
 
 async function adoptExistingToolAgents(args: {
+  tool: string;
   rootDir: string;
   agentsDir: string;
   conflictMode: "keep-canonical" | "keep-existing";
 }): Promise<ExistingManagedItem[]> {
   const adopted: ExistingManagedItem[] = [];
-  const agents = await loadAgentsFromRoot(args.agentsDir);
+  const agents = await loadManagedAgentsFromTool({
+    tool: args.tool,
+    agentsDir: args.agentsDir,
+  });
   for (const agent of agents) {
     const canonicalPath = join(
       args.rootDir,
@@ -1123,6 +1362,87 @@ async function adoptExistingToolAgents(args: {
   return adopted;
 }
 
+async function planExistingAutomationAdoption(args: {
+  rootDir: string;
+  automationDir: string;
+}): Promise<ExistingManagedImportPlan> {
+  const plan = emptyManagedImportPlan();
+  const liveAutomations = await loadAutomationEntries(args.automationDir);
+  const canonicalAutomations = new Map(
+    (await loadCanonicalAutomations(args.rootDir)).map((entry) => [
+      entry.name,
+      entry,
+    ])
+  );
+
+  for (const liveAutomation of liveAutomations) {
+    const canonicalAutomation = canonicalAutomations.get(liveAutomation.name);
+    if (!canonicalAutomation) {
+      continue;
+    }
+    const item: ExistingManagedItem = {
+      kind: "automation",
+      name: liveAutomation.name,
+      livePath: liveAutomation.sourceDir,
+      canonicalPath: join(args.rootDir, "automations", liveAutomation.name),
+    };
+    if (automationEntriesEqual(liveAutomation, canonicalAutomation)) {
+      plan.identical.push(item);
+    } else {
+      plan.conflicts.push(item);
+    }
+  }
+
+  return mergeManagedImportPlans(plan);
+}
+
+async function adoptExistingAutomations(args: {
+  rootDir: string;
+  automationDir: string;
+  conflictMode: "keep-canonical" | "keep-existing";
+}): Promise<ExistingManagedItem[]> {
+  if (args.conflictMode !== "keep-existing") {
+    return [];
+  }
+
+  const adopted: ExistingManagedItem[] = [];
+  const liveAutomations = await loadAutomationEntries(args.automationDir);
+  const canonicalAutomations = new Map(
+    (await loadCanonicalAutomations(args.rootDir)).map((entry) => [
+      entry.name,
+      entry,
+    ])
+  );
+
+  for (const liveAutomation of liveAutomations) {
+    const canonicalAutomation = canonicalAutomations.get(liveAutomation.name);
+    if (
+      !(
+        canonicalAutomation &&
+        !automationEntriesEqual(liveAutomation, canonicalAutomation)
+      )
+    ) {
+      continue;
+    }
+    const canonicalPath = join(
+      args.rootDir,
+      "automations",
+      liveAutomation.name
+    );
+    await ensureDir(dirname(canonicalPath));
+    await rm(canonicalPath, { recursive: true, force: true });
+    await cp(liveAutomation.sourceDir, canonicalPath, { recursive: true });
+    adopted.push({
+      kind: "automation",
+      name: liveAutomation.name,
+      livePath: liveAutomation.sourceDir,
+      canonicalPath,
+    });
+  }
+
+  return adopted;
+}
+
 async function planExistingGlobalDocAdoption(args: {
   rootDir: string;
   tool: string;
@@ -1784,10 +2104,17 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
     asManagedSkillPlan(existingSkillPlan),
     toolPaths.agentsDir
       ? await planExistingToolAgentAdoption({
+          tool,
           rootDir,
           agentsDir: toolPaths.agentsDir,
         })
       : emptyManagedImportPlan(),
+    toolPaths.automationDir
+      ? await planExistingAutomationAdoption({
+          rootDir,
+          automationDir: toolPaths.automationDir,
+        })
+      : emptyManagedImportPlan(),
     toolPaths.toolHome
       ? await planExistingGlobalDocAdoption({
           rootDir,
@@ -1826,6 +2153,7 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
   if (
     (toolPaths.skillsDir ||
       toolPaths.agentsDir ||
+      toolPaths.automationDir ||
       toolPaths.toolHome ||
       toolPaths.rulesDir ||
       toolPaths.toolConfig ||
@@ -1900,12 +2228,21 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
   }
   if (toolPaths.agentsDir && opts.adoptExisting) {
     const result = await adoptExistingToolAgents({
+      tool,
       rootDir,
       agentsDir: toolPaths.agentsDir,
       conflictMode: importConflictMode,
     });
     adoptedSkills.push(...result.map((item) => item.name));
   }
+  if (toolPaths.automationDir && opts.adoptExisting) {
+    const result = await adoptExistingAutomations({
+      rootDir,
+      automationDir: toolPaths.automationDir,
+      conflictMode: importConflictMode,
+    });
+    adoptedSkills.push(...result.map((item) => `${item.kind}:${item.name}`));
+  }
   if (toolPaths.toolHome && opts.adoptExisting) {
     const result = await adoptExistingGlobalDocs({
       rootDir,
@@ -1957,6 +2294,12 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
         tool,
       })
     : null;
+  const automationPreview = toolPaths.automationDir
+    ? await planAutomationFileChanges({
+        automationDir: toolPaths.automationDir,
+        rootDir,
+      })
+    : null;
   const globalDocsPreview = toolPaths.toolHome
     ? await planToolGlobalDocsSync({
         homeDir: home,
@@ -2048,6 +2391,16 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
     });
   }
 
+  if (toolPaths.automationDir && automationPreview) {
+    await ensureDir(toolPaths.automationDir);
+    await applyRenderedRemoves(automationPreview.remove);
+    await applyRenderedWrites({
+      contents: automationPreview.contents,
+      targets: Array.from(automationPreview.contents.keys()),
+    });
+    await pruneEmptyParents(automationPreview.remove, toolPaths.automationDir);
+  }
+
   if (toolPaths.toolHome && globalDocsPreview) {
     await ensureDir(toolPaths.toolHome);
     await applyRenderedRemoves(globalDocsPreview.remove);
@@ -2086,6 +2439,7 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
     skillsDir: toolPaths.skillsDir,
     mcpConfig: toolPaths.mcpConfig,
     agentsDir: toolPaths.agentsDir,
+    automationDir: toolPaths.automationDir,
     toolHome: globalDocsPreview?.managedTargets.length
       ? toolPaths.toolHome
       : undefined,
@@ -2123,6 +2477,15 @@ export async function manageTool(tool: string, opts: ManageOptions = {}) {
       sources: agentPreview.sources,
     });
   }
+  if (automationPreview) {
+    updateRenderedTargetState({
+      entry: managedEntry,
+      writtenTargets: Array.from(automationPreview.contents.keys()),
+      removedTargets: automationPreview.remove,
+      contents: automationPreview.contents,
+      sources: automationPreview.sources,
+    });
+  }
   if (globalDocsPreview) {
     updateRenderedTargetState({
       entry: managedEntry,
@@ -2238,6 +2601,14 @@ export async function unmanageTool(tool: string, opts: ManageOptions = {}) {
     });
   }
 
+  if (entry.automationDir) {
+    const automationTargets = Object.keys(entry.renderedTargets ?? {}).filter(
+      (targetPath) => targetPath.startsWith(join(entry.automationDir!, ""))
+    );
+    await applyRenderedRemoves(automationTargets);
+    await pruneEmptyParents(automationTargets, entry.automationDir);
+  }
+
   if (entry.globalAgentsPath) {
     await restoreBackup({
       original: entry.globalAgentsPath,
@@ -2320,6 +2691,15 @@ async function repairManagedToolEntry(args: {
     changed = true;
   }
 
+  if (
+    !next.automationDir &&
+    toolPaths.automationDir &&
+    (await canonicalAutomationsExist(rootDir))
+  ) {
+    next.automationDir = toolPaths.automationDir;
+    changed = true;
+  }
+
   if (toolPaths.toolHome && !next.toolHome) {
     const preview = await syncToolGlobalDocs({
       homeDir,
@@ -2406,6 +2786,7 @@ async function planRenderedTargetConflicts(args: {
   desiredContents: Map<string, string>;
   desiredSources: Map<string, string>;
   conflictMode?: "warn" | "overwrite";
+  protectAllSources?: boolean;
 }): Promise<RenderedApplyPlan> {
   if (args.conflictMode === "overwrite") {
     return {
@@ -2433,7 +2814,7 @@ async function planRenderedTargetConflicts(args: {
       continue;
     }
     const sourceKind = renderedSourceKindForPath(sourcePath);
-    if (sourceKind !== "builtin") {
+    if (sourceKind !== "builtin" && !args.protectAllSources) {
       if (args.desiredWrites.includes(targetPath)) {
         write.push(targetPath);
       } else {
@@ -2452,8 +2833,16 @@ async function planRenderedTargetConflicts(args: {
     }
 
     const currentHash = renderedHash(current);
+    const desiredHash = args.desiredContents.get(targetPath)
+      ? renderedHash(args.desiredContents.get(targetPath)!)
+      : null;
     if (prior?.hash) {
-      if (currentHash === prior.hash) {
+      if (
+        currentHash === prior.hash ||
+        (args.desiredWrites.includes(targetPath) &&
+          desiredHash != null &&
+          currentHash === desiredHash)
+      ) {
         if (args.desiredWrites.includes(targetPath)) {
           write.push(targetPath);
         } else {
@@ -2470,6 +2859,15 @@ async function planRenderedTargetConflicts(args: {
       continue;
     }
 
+    if (
+      args.desiredWrites.includes(targetPath) &&
+      desiredHash != null &&
+      currentHash === desiredHash
+    ) {
+      write.push(targetPath);
+      continue;
+    }
+
     conflicts.push({
       targetPath,
       sourcePath,
@@ -2496,8 +2894,14 @@ function logRenderedConflicts(
       conflict.reason === "unknown_state"
         ? "no prior managed hash is recorded"
         : "local edits were detected";
+    const surface =
+      conflict.sourceKind === "builtin"
+        ? "builtin-backed target"
+        : "managed target";
     console.warn(
-      `${tool}: ${verb} builtin-backed target ${conflict.targetPath} because ${state}. Rerun with "--builtin-conflicts overwrite" to replace it with the latest packaged default.`
+      conflict.sourceKind === "builtin"
+        ? `${tool}: ${verb} ${surface} ${conflict.targetPath} because ${state}. Rerun with "--builtin-conflicts overwrite" to replace it with the latest packaged default.`
+        : `${tool}: ${verb} ${surface} ${conflict.targetPath} because ${state}.`
     );
   }
 }
@@ -2525,6 +2929,24 @@ async function applyRenderedRemoves(targets: string[]) {
   }
 }
 
+async function pruneEmptyParents(targets: string[], stopDir: string) {
+  const candidateDirs = Array.from(
+    new Set(targets.map((pathValue) => dirname(pathValue)))
+  ).sort((a, b) => b.length - a.length);
+
+  for (const startDir of candidateDirs) {
+    let currentDir = startDir;
+    while (currentDir.startsWith(join(stopDir, "")) && currentDir !== stopDir) {
+      const entries = await readdir(currentDir).catch(() => null);
+      if (!(entries && entries.length === 0)) {
+        break;
+      }
+      await rm(currentDir, { recursive: true, force: true });
+      currentDir = dirname(currentDir);
+    }
+  }
+}
+
 function updateRenderedTargetState(args: {
   entry: ManagedToolState;
   writtenTargets: string[];
@@ -2558,6 +2980,8 @@ function logSyncDryRun({
   mcpPlan,
   agentPlan,
   agentConflicts,
+  automationPlan,
+  automationConflicts,
   globalDocsPlan,
   globalDocsConflicts,
   rulesPlan,
@@ -2571,6 +2995,8 @@ function logSyncDryRun({
   mcpPlan: { needsWrite: boolean };
   agentPlan: { add: string[]; remove: string[] };
   agentConflicts: RenderedConflict[];
+  automationPlan: { write: string[]; remove: string[] };
+  automationConflicts: RenderedConflict[];
   globalDocsPlan: { write: string[]; remove: string[] };
   globalDocsConflicts: RenderedConflict[];
   rulesPlan: { write: string[]; remove: string[] };
@@ -2591,6 +3017,13 @@ function logSyncDryRun({
     console.log(`${tool}: would remove agent ${p}`);
   }
   logRenderedConflicts(tool, agentConflicts, true);
+  for (const p of automationPlan.write) {
+    console.log(`${tool}: would write automation ${p}`);
+  }
+  for (const p of automationPlan.remove) {
+    console.log(`${tool}: would remove automation ${p}`);
+  }
+  logRenderedConflicts(tool, automationConflicts, true);
   for (const p of globalDocsPlan.write) {
     console.log(`${tool}: would write global doc ${p}`);
   }
@@ -2620,6 +3053,8 @@ function logSyncDryRun({
     skillPlan.remove.length === 0 &&
     agentPlan.add.length === 0 &&
     agentPlan.remove.length === 0 &&
+    automationPlan.write.length === 0 &&
+    automationPlan.remove.length === 0 &&
     globalDocsPlan.write.length === 0 &&
     globalDocsPlan.remove.length === 0 &&
     rulesPlan.write.length === 0 &&
@@ -2628,6 +3063,7 @@ function logSyncDryRun({
     !configPlan.remove &&
     !mcpPlan.needsWrite &&
     agentConflicts.length === 0 &&
+    automationConflicts.length === 0 &&
     globalDocsConflicts.length === 0 &&
     rulesConflicts.length === 0 &&
     configConflicts.length === 0
@@ -2657,6 +3093,7 @@ async function repairManagedCanonicalContent(args: {
 
   if (args.entry.agentsBackup) {
     const items = await adoptExistingToolAgents({
+      tool: args.entry.tool,
       rootDir: args.rootDir,
       agentsDir: args.entry.agentsBackup,
       conflictMode: "keep-canonical",
@@ -2767,6 +3204,13 @@ async function syncManagedToolEntry({
         tool,
       })
     : { add: [], remove: [], contents: new Map(), sources: new Map() };
+  const automationPlan = entry.automationDir
+    ? await planAutomationFileChanges({
+        automationDir: entry.automationDir,
+        rootDir,
+        previouslyManagedTargets: Object.keys(entry.renderedTargets ?? {}),
+      })
+    : { add: [], remove: [], contents: new Map(), sources: new Map() };
 
   const mcpPlan = entry.mcpConfig
     ? await syncMcpConfig({
@@ -2846,6 +3290,15 @@ async function syncManagedToolEntry({
     desiredSources: globalDocsPlan.sources,
     conflictMode: builtinConflictMode,
   });
+  const automationRendered = await planRenderedTargetConflicts({
+    entry,
+    desiredWrites: automationPlan.add,
+    desiredRemoves: automationPlan.remove,
+    desiredContents: automationPlan.contents,
+    desiredSources: automationPlan.sources,
+    conflictMode: builtinConflictMode,
+    protectAllSources: true,
+  });
   const rulesRendered = await planRenderedTargetConflicts({
     entry,
     desiredWrites: rulesPlan.write,
@@ -2882,6 +3335,11 @@ async function syncManagedToolEntry({
       mcpPlan,
       agentPlan: { add: agentRendered.write, remove: agentRendered.remove },
       agentConflicts: agentRendered.conflicts,
+      automationPlan: {
+        write: automationRendered.write,
+        remove: automationRendered.remove,
+      },
+      automationConflicts: automationRendered.conflicts,
       globalDocsPlan: {
         write: globalDocsRendered.write,
         remove: globalDocsRendered.remove,
@@ -2902,6 +3360,14 @@ async function syncManagedToolEntry({
       contents: agentPlan.contents,
       targets: agentRendered.write,
     });
+    await applyRenderedRemoves(automationRendered.remove);
+    await applyRenderedWrites({
+      contents: automationPlan.contents,
+      targets: automationRendered.write,
+    });
+    if (entry.automationDir) {
+      await pruneEmptyParents(automationRendered.remove, entry.automationDir);
+    }
     await applyRenderedRemoves(globalDocsRendered.remove);
     await applyRenderedWrites({
       contents: globalDocsPlan.contents,
@@ -2918,6 +3384,7 @@ async function syncManagedToolEntry({
       targets: configRendered.write,
     });
     logRenderedConflicts(tool, agentRendered.conflicts);
+    logRenderedConflicts(tool, automationRendered.conflicts);
     logRenderedConflicts(tool, globalDocsRendered.conflicts);
     logRenderedConflicts(tool, rulesRendered.conflicts);
     logRenderedConflicts(tool, configRendered.conflicts);
@@ -2929,6 +3396,13 @@ async function syncManagedToolEntry({
       contents: agentPlan.contents,
       sources: agentPlan.sources,
     });
+    updateRenderedTargetState({
+      entry,
+      writtenTargets: automationRendered.write,
+      removedTargets: automationRendered.remove,
+      contents: automationPlan.contents,
+      sources: automationPlan.sources,
+    });
     updateRenderedTargetState({
       entry,
       writtenTargets: globalDocsRendered.write,