agent-conf 2.0.4 → 2.1.1

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  CanonicalRepoConfigSchema,
   addManagedMetadata,
   buildAgentsMd,
   checkAllManagedFiles,
@@ -12,7 +13,7 @@ import {
   parseGlobalBlockMetadata,
   stripMetadataComments,
   validateSkillFrontmatter
-} from "./chunk-EN5LTDER.js";
+} from "./chunk-MZ2GBXCB.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -49,7 +50,9 @@ var ContentSchema = z.object({
     merged: z.boolean()
   }),
   skills: z.array(z.string()),
-  targets: z.array(z.string()).optional()
+  targets: z.array(z.string()).optional(),
+  /** Marker prefix used for managed content (default: "agent-conf") */
+  marker_prefix: z.string().optional()
 });
 var LockfileSchema = z.object({
   version: z.literal("1"),
@@ -64,9 +67,8 @@ var LockfileSchema = z.object({
 // src/core/lockfile.ts
 var CONFIG_DIR = ".agent-conf";
 var LOCKFILE_NAME = "lockfile.json";
-var CLI_VERSION = "0.1.0";
 function getBuildCommit() {
-  return true ? "ceff9aa02d2b0d813fff15615e9a0b530148a6ac" : "unknown";
+  return true ? "641fa01067697521d17cc7883300f8e326a97724" : "unknown";
 }
 function getLockfilePath(targetDir) {
   return path.join(targetDir, CONFIG_DIR, LOCKFILE_NAME);
@@ -97,9 +99,10 @@ async function writeLockfile(targetDir, options) {
         merged: true
       },
       skills: options.skills,
-      targets: options.targets ?? ["claude"]
+      targets: options.targets ?? ["claude"],
+      marker_prefix: options.markerPrefix
     },
-    cli_version: CLI_VERSION
+    cli_version: getCliVersion()
   };
   await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
   await fs.writeFile(lockfilePath, `${JSON.stringify(lockfile, null, 2)}
@@ -111,7 +114,7 @@ function hashContent(content) {
   return `sha256:${hash.slice(0, 12)}`;
 }
 function getCliVersion() {
-  return CLI_VERSION;
+  return true ? "2.1.1" : "0.0.0";
 }
 async function checkCliVersionMismatch(targetDir) {
   const lockfile = await readLockfile(targetDir);
@@ -153,14 +156,17 @@ async function checkCommand(options = {}) {
     return;
   }
   const targets = lockfile.content.targets ?? ["claude"];
+  const markerPrefix = lockfile.content.marker_prefix;
   const modifiedFiles = [];
-  const allFiles = await checkAllManagedFiles(targetDir, targets);
+  const checkOptions = markerPrefix ? { markerPrefix, metadataPrefix: markerPrefix } : {};
+  const allFiles = await checkAllManagedFiles(targetDir, targets, checkOptions);
+  const keyPrefix = markerPrefix ? `${markerPrefix.replace(/-/g, "_")}_` : "agent_conf_";
   for (const file of allFiles) {
     if (!file.hasChanges) continue;
     if (file.type === "agents") {
       const agentsMdPath = path2.join(targetDir, "AGENTS.md");
       const content = await fs2.readFile(agentsMdPath, "utf-8");
-      const parsed = parseAgentsMd(content);
+      const parsed = parseAgentsMd(content, markerPrefix ? { prefix: markerPrefix } : void 0);
       if (parsed.globalBlock) {
         const metadata = parseGlobalBlockMetadata(parsed.globalBlock);
         const contentWithoutMeta = stripMetadataComments(parsed.globalBlock);
@@ -177,8 +183,11 @@ async function checkCommand(options = {}) {
       const content = await fs2.readFile(skillPath, "utf-8");
       const { frontmatter } = parseFrontmatter(content);
       const metadata = frontmatter.metadata;
-      const storedHash = metadata?.agent_conf_content_hash ?? "unknown";
-      const currentHash = computeContentHash(content);
+      const storedHash = metadata?.[`${keyPrefix}content_hash`] ?? "unknown";
+      const currentHash = computeContentHash(
+        content,
+        markerPrefix ? { metadataPrefix: markerPrefix } : void 0
+      );
       modifiedFiles.push({
         path: file.path,
         type: "skill",
@@ -187,6 +196,23 @@ async function checkCommand(options = {}) {
       });
     }
   }
+  if (allFiles.length === 0) {
+    if (options.quiet) {
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc.bold("agent-conf check"));
+    console.log();
+    console.log(`${pc.red("\u2717")} No managed files found`);
+    console.log();
+    console.log(pc.dim("This repository appears to be synced but no managed files were detected."));
+    if (markerPrefix) {
+      console.log(pc.dim(`Expected marker prefix: ${markerPrefix}`));
+    }
+    console.log(pc.dim("Run 'agent-conf sync' to restore the managed files."));
+    console.log();
+    process.exit(1);
+  }
   if (options.quiet) {
     if (modifiedFiles.length > 0) {
       process.exit(1);
@@ -568,9 +594,10 @@ function stripAgentsReference(content) {
 }
 async function mergeAgentsMd(targetDir, globalContent, _source, options = { override: false }) {
   const existing = await gatherExistingContent(targetDir);
+  const markerOptions = options.markerPrefix ? { prefix: options.markerPrefix } : void 0;
   const contentToMerge = [];
   if (existing.agentsMd !== null && !options.override) {
-    const parsed = parseAgentsMd(existing.agentsMd);
+    const parsed = parseAgentsMd(existing.agentsMd, markerOptions);
     if (parsed.hasMarkers) {
       const repoContent2 = extractRepoBlockContent(parsed);
       if (repoContent2) {
@@ -589,7 +616,7 @@ async function mergeAgentsMd(targetDir, globalContent, _source, options = { over
     }
   }
   const repoContent = contentToMerge.length > 0 ? contentToMerge.join("\n\n") : null;
-  const content = buildAgentsMd(globalContent, repoContent, {});
+  const content = buildAgentsMd(globalContent, repoContent, {}, markerOptions);
   const merged = !options.override && (existing.agentsMd !== null || existing.claudeMd !== null);
   const preservedRepoContent = contentToMerge.length > 0;
   return {
@@ -676,9 +703,11 @@ function getTargetConfig(target) {
 
 // src/core/sync.ts
 async function sync(targetDir, resolvedSource, options = { override: false, targets: ["claude"] }) {
+  const markerPrefix = resolvedSource.markerPrefix;
   const globalContent = await fs5.readFile(resolvedSource.agentsMdPath, "utf-8");
   const mergeResult = await mergeAgentsMd(targetDir, globalContent, resolvedSource.source, {
-    override: options.override
+    override: options.override,
+    markerPrefix
   });
   await writeAgentsMd(targetDir, mergeResult.content);
   const skillDirs = await fg("*/", {
@@ -707,7 +736,8 @@ async function sync(targetDir, resolvedSource, options = { override: false, targ
       targetDir,
       resolvedSource.skillsPath,
       skillNames,
-      config
+      config,
+      markerPrefix
     );
     totalCopied += skillsCopied;
     let instructionsResult;
@@ -735,7 +765,8 @@ async function sync(targetDir, resolvedSource, options = { override: false, targ
     source: resolvedSource.source,
     globalBlockContent: globalContent,
     skills: skillNames,
-    targets: options.targets
+    targets: options.targets,
+    markerPrefix
   };
   if (options.pinnedVersion) {
     lockfileOptions.pinnedVersion = options.pinnedVersion;
@@ -755,18 +786,18 @@ async function sync(targetDir, resolvedSource, options = { override: false, targ
     }
   };
 }
-async function syncSkillsToTarget(targetDir, sourceSkillsPath, skillNames, config) {
+async function syncSkillsToTarget(targetDir, sourceSkillsPath, skillNames, config, metadataPrefix) {
   const targetSkillsPath = path5.join(targetDir, config.dir, "skills");
   let copied = 0;
   for (const skillName of skillNames) {
     const sourceDir = path5.join(sourceSkillsPath, skillName);
     const targetSkillDir = path5.join(targetSkillsPath, skillName);
-    const filesCopied = await copySkillDirectory(sourceDir, targetSkillDir);
+    const filesCopied = await copySkillDirectory(sourceDir, targetSkillDir, metadataPrefix);
     copied += filesCopied;
   }
   return copied;
 }
-async function copySkillDirectory(sourceDir, targetDir) {
+async function copySkillDirectory(sourceDir, targetDir, metadataPrefix) {
   await fs5.mkdir(targetDir, { recursive: true });
   const entries = await fs5.readdir(sourceDir, { withFileTypes: true });
   let copied = 0;
@@ -774,10 +805,10 @@ async function copySkillDirectory(sourceDir, targetDir) {
     const sourcePath = path5.join(sourceDir, entry.name);
     const targetPath = path5.join(targetDir, entry.name);
     if (entry.isDirectory()) {
-      copied += await copySkillDirectory(sourcePath, targetPath);
+      copied += await copySkillDirectory(sourcePath, targetPath, metadataPrefix);
     } else if (entry.name === "SKILL.md") {
       const content = await fs5.readFile(sourcePath, "utf-8");
-      const contentWithMetadata = addManagedMetadata(content);
+      const contentWithMetadata = addManagedMetadata(content, { metadataPrefix });
       await fs5.writeFile(targetPath, contentWithMetadata, "utf-8");
       copied++;
     } else {
@@ -817,9 +848,10 @@ async function getSyncStatus(targetDir) {
 function findOrphanedSkills(previousSkills, currentSkills) {
   return previousSkills.filter((skill) => !currentSkills.includes(skill));
 }
-async function deleteOrphanedSkills(targetDir, orphanedSkills, targets, previouslyTrackedSkills) {
+async function deleteOrphanedSkills(targetDir, orphanedSkills, targets, previouslyTrackedSkills, options = {}) {
   const deleted = [];
   const skipped = [];
+  const metadataOptions = options.metadataPrefix ? { metadataPrefix: options.metadataPrefix } : void 0;
   for (const skillName of orphanedSkills) {
     let wasDeleted = false;
     for (const target of targets) {
@@ -832,15 +864,15 @@ async function deleteOrphanedSkills(targetDir, orphanedSkills, targets, previous
       const skillMdPath = path5.join(skillDir, "SKILL.md");
       try {
         const content = await fs5.readFile(skillMdPath, "utf-8");
-        const { isManaged, hasManualChanges } = await import("./skill-metadata-XANK6RZP.js");
-        if (!isManaged(content)) {
+        const { isManaged, hasManualChanges } = await import("./skill-metadata-DK2WBJJ3.js");
+        if (!isManaged(content, metadataOptions)) {
           if (!skipped.includes(skillName)) {
             skipped.push(skillName);
           }
           continue;
         }
         const wasInPreviousLockfile = previouslyTrackedSkills.includes(skillName);
-        const isUnmodified = !hasManualChanges(content);
+        const isUnmodified = !hasManualChanges(content, metadataOptions);
         if (!wasInPreviousLockfile && !isUnmodified) {
           if (!skipped.includes(skillName)) {
             skipped.push(skillName);
@@ -864,7 +896,7 @@ async function deleteOrphanedSkills(targetDir, orphanedSkills, targets, previous
 }
 
 // src/commands/shared.ts
-import * as path11 from "path";
+import * as path12 from "path";
 import * as prompts3 from "@clack/prompts";
 import pc5 from "picocolors";
 
@@ -982,16 +1014,40 @@ async function installPreCommitHook(targetDir, config) {
 
 // src/core/source.ts
 import { exec } from "child_process";
-import * as fs7 from "fs/promises";
-import * as path7 from "path";
+import * as fs8 from "fs/promises";
+import * as path8 from "path";
 import { promisify } from "util";
 import { simpleGit } from "simple-git";
+
+// src/config/loader.ts
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
+import { parse as parseYaml } from "yaml";
+var CANONICAL_REPO_CONFIG = "agent-conf.yaml";
+async function loadCanonicalRepoConfig(basePath) {
+  const configPath = path7.join(basePath, CANONICAL_REPO_CONFIG);
+  try {
+    const content = await fs7.readFile(configPath, "utf-8");
+    const parsed = parseYaml(content);
+    return CanonicalRepoConfigSchema.parse(parsed);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw new Error(`Failed to load ${CANONICAL_REPO_CONFIG}: ${error}`);
+  }
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/core/source.ts
 var execAsync = promisify(exec);
 var DEFAULT_REF = "master";
 async function resolveLocalSource(options = {}) {
   let basePath;
   if (options.path) {
-    basePath = path7.resolve(options.path);
+    basePath = path8.resolve(options.path);
   } else {
     basePath = await findCanonicalRepo(process.cwd());
   }
@@ -1003,6 +1059,8 @@ async function resolveLocalSource(options = {}) {
     commitSha = log2.latest?.hash;
   } catch {
   }
+  const canonicalConfig = await loadCanonicalRepoConfig(basePath);
+  const markerPrefix = canonicalConfig?.markers.prefix ?? "agent-conf";
   const source = {
     type: "local",
     path: basePath,
@@ -1011,8 +1069,9 @@ async function resolveLocalSource(options = {}) {
   return {
     source,
     basePath,
-    agentsMdPath: path7.join(basePath, "instructions", "AGENTS.md"),
-    skillsPath: path7.join(basePath, "skills")
+    agentsMdPath: path8.join(basePath, "instructions", "AGENTS.md"),
+    skillsPath: path8.join(basePath, "skills"),
+    markerPrefix
   };
 }
 async function resolveGithubSource(options, tempDir) {
@@ -1021,6 +1080,8 @@ async function resolveGithubSource(options, tempDir) {
   const clonedGit = simpleGit(tempDir);
   const log2 = await clonedGit.log({ maxCount: 1 });
   const commitSha = log2.latest?.hash ?? "";
+  const canonicalConfig = await loadCanonicalRepoConfig(tempDir);
+  const markerPrefix = canonicalConfig?.markers.prefix ?? "agent-conf";
   const source = {
     type: "github",
     repository,
@@ -1030,8 +1091,9 @@ async function resolveGithubSource(options, tempDir) {
   return {
     source,
     basePath: tempDir,
-    agentsMdPath: path7.join(tempDir, "instructions", "AGENTS.md"),
-    skillsPath: path7.join(tempDir, "skills")
+    agentsMdPath: path8.join(tempDir, "instructions", "AGENTS.md"),
+    skillsPath: path8.join(tempDir, "skills"),
+    markerPrefix
   };
 }
 async function cloneRepository(repository, ref, tempDir) {
@@ -1056,19 +1118,19 @@ async function isGhAvailable() {
   }
 }
 async function findCanonicalRepo(startDir) {
-  let currentDir = path7.resolve(startDir);
-  const root = path7.parse(currentDir).root;
+  let currentDir = path8.resolve(startDir);
+  const root = path8.parse(currentDir).root;
   let checkDir = currentDir;
   while (checkDir !== root) {
     if (await isCanonicalRepo(checkDir)) {
       return checkDir;
     }
-    checkDir = path7.dirname(checkDir);
+    checkDir = path8.dirname(checkDir);
   }
-  currentDir = path7.resolve(startDir);
+  currentDir = path8.resolve(startDir);
   while (currentDir !== root) {
-    const parentDir = path7.dirname(currentDir);
-    const siblingCanonicalRepo = path7.join(parentDir, "agent-conf");
+    const parentDir = path8.dirname(currentDir);
+    const siblingCanonicalRepo = path8.join(parentDir, "agent-conf");
     if (await isCanonicalRepo(siblingCanonicalRepo)) {
       return siblingCanonicalRepo;
     }
@@ -1080,15 +1142,15 @@ async function findCanonicalRepo(startDir) {
 }
 async function isCanonicalRepo(dir) {
   try {
-    const stat4 = await fs7.stat(dir).catch(() => null);
+    const stat4 = await fs8.stat(dir).catch(() => null);
     if (!stat4?.isDirectory()) {
       return false;
     }
-    const instructionsPath = path7.join(dir, "instructions", "AGENTS.md");
-    const skillsPath = path7.join(dir, "skills");
+    const instructionsPath = path8.join(dir, "instructions", "AGENTS.md");
+    const skillsPath = path8.join(dir, "skills");
     const [instructionsExists, skillsExists] = await Promise.all([
-      fs7.access(instructionsPath).then(() => true).catch(() => false),
-      fs7.access(skillsPath).then(() => true).catch(() => false)
+      fs8.access(instructionsPath).then(() => true).catch(() => false),
+      fs8.access(skillsPath).then(() => true).catch(() => false)
     ]);
     if (!instructionsExists || !skillsExists) {
       return false;
@@ -1110,11 +1172,11 @@ async function isCanonicalRepo(dir) {
   }
 }
 async function validateCanonicalRepo(basePath) {
-  const agentsMdPath = path7.join(basePath, "instructions", "AGENTS.md");
-  const skillsPath = path7.join(basePath, "skills");
+  const agentsMdPath = path8.join(basePath, "instructions", "AGENTS.md");
+  const skillsPath = path8.join(basePath, "skills");
   const [agentsMdExists, skillsExists] = await Promise.all([
-    fs7.access(agentsMdPath).then(() => true).catch(() => false),
-    fs7.access(skillsPath).then(() => true).catch(() => false)
+    fs8.access(agentsMdPath).then(() => true).catch(() => false),
+    fs8.access(skillsPath).then(() => true).catch(() => false)
   ]);
   if (!agentsMdExists) {
     throw new Error(`Invalid canonical repository: missing instructions/AGENTS.md at ${basePath}`);
@@ -1233,8 +1295,8 @@ function compareVersions(a, b) {
 }
 
 // src/core/workflows.ts
-import * as fs8 from "fs/promises";
-import * as path8 from "path";
+import * as fs9 from "fs/promises";
+import * as path9 from "path";
 var DEFAULT_CLI_NAME2 = "agent-conf";
 var WORKFLOWS_DIR = ".github/workflows";
 function getWorkflowConfig(sourceRepo, config) {
@@ -1263,10 +1325,10 @@ function getWorkflowFiles(config) {
   ];
 }
 function getWorkflowsDir(repoRoot) {
-  return path8.join(repoRoot, WORKFLOWS_DIR);
+  return path9.join(repoRoot, WORKFLOWS_DIR);
 }
 function getWorkflowPath(repoRoot, filename) {
-  return path8.join(repoRoot, WORKFLOWS_DIR, filename);
+  return path9.join(repoRoot, WORKFLOWS_DIR, filename);
 }
 function generateSyncWorkflow(versionRef, config) {
   const { sourceRepo, cliName, secretName } = config;
@@ -1356,13 +1418,13 @@ function generateWorkflow(workflow, versionRef, config) {
 }
 async function ensureWorkflowsDir(repoRoot) {
   const dir = getWorkflowsDir(repoRoot);
-  await fs8.mkdir(dir, { recursive: true });
+  await fs9.mkdir(dir, { recursive: true });
 }
 async function writeWorkflow(repoRoot, workflow, versionRef, config) {
   await ensureWorkflowsDir(repoRoot);
   const filePath = getWorkflowPath(repoRoot, workflow.filename);
   const content = generateWorkflow(workflow, versionRef, config);
-  await fs8.writeFile(filePath, content, "utf-8");
+  await fs9.writeFile(filePath, content, "utf-8");
 }
 async function syncWorkflows(repoRoot, versionRef, sourceRepo, resolvedConfig) {
   const config = getWorkflowConfig(sourceRepo, resolvedConfig);
@@ -1377,7 +1439,7 @@ async function syncWorkflows(repoRoot, versionRef, sourceRepo, resolvedConfig) {
     const expectedContent = generateWorkflow(workflow, versionRef, config);
     let existingContent = null;
     try {
-      existingContent = await fs8.readFile(filePath, "utf-8");
+      existingContent = await fs9.readFile(filePath, "utf-8");
     } catch {
     }
     if (existingContent === null) {
@@ -1394,15 +1456,15 @@ async function syncWorkflows(repoRoot, versionRef, sourceRepo, resolvedConfig) {
 }
 
 // src/utils/fs.ts
-import * as fs9 from "fs/promises";
+import * as fs10 from "fs/promises";
 import * as os2 from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 async function ensureDir(dirPath) {
-  await fs9.mkdir(dirPath, { recursive: true });
+  await fs10.mkdir(dirPath, { recursive: true });
 }
 async function fileExists(filePath) {
   try {
-    await fs9.access(filePath);
+    await fs10.access(filePath);
     return true;
   } catch {
     return false;
@@ -1410,7 +1472,7 @@ async function fileExists(filePath) {
 }
 async function directoryExists(dirPath) {
   try {
-    const stat4 = await fs9.stat(dirPath);
+    const stat4 = await fs10.stat(dirPath);
     return stat4.isDirectory();
   } catch {
     return false;
@@ -1418,28 +1480,28 @@ async function directoryExists(dirPath) {
 }
 async function createTempDir(prefix = "agent-conf-") {
   const tmpDir = os2.tmpdir();
-  return fs9.mkdtemp(path9.join(tmpDir, prefix));
+  return fs10.mkdtemp(path10.join(tmpDir, prefix));
 }
 async function removeTempDir(dirPath) {
   try {
-    await fs9.rm(dirPath, { recursive: true, force: true });
+    await fs10.rm(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
 function resolvePath(inputPath) {
   if (inputPath.startsWith("~")) {
-    return path9.join(os2.homedir(), inputPath.slice(1));
+    return path10.join(os2.homedir(), inputPath.slice(1));
   }
-  return path9.resolve(inputPath);
+  return path10.resolve(inputPath);
 }
 
 // src/utils/git.ts
-import * as fs10 from "fs/promises";
-import * as path10 from "path";
+import * as fs11 from "fs/promises";
+import * as path11 from "path";
 import { simpleGit as simpleGit2 } from "simple-git";
 async function directoryExistsForGit(dir) {
   try {
-    const stat4 = await fs10.stat(dir);
+    const stat4 = await fs11.stat(dir);
     return stat4.isDirectory();
   } catch {
     return false;
@@ -1466,7 +1528,7 @@ async function getGitProjectName(dir) {
   if (!gitRoot) {
     return null;
   }
-  return path10.basename(gitRoot);
+  return path11.basename(gitRoot);
 }
 async function isGitRoot(dir) {
   if (!await directoryExistsForGit(dir)) {
@@ -1477,11 +1539,11 @@ async function isGitRoot(dir) {
     return false;
   }
   try {
-    const realDir = await fs10.realpath(dir);
-    const realGitRoot = await fs10.realpath(gitRoot);
+    const realDir = await fs11.realpath(dir);
+    const realGitRoot = await fs11.realpath(gitRoot);
     return realDir === realGitRoot;
   } catch {
-    return path10.resolve(dir) === path10.resolve(gitRoot);
+    return path11.resolve(dir) === path11.resolve(gitRoot);
   }
 }
 async function getGitOrganization(dir) {
@@ -1790,7 +1852,7 @@ async function performSync(options) {
     console.log();
     console.log(pc5.bold("Sync complete:"));
     console.log();
-    const agentsMdPath = formatPath(path11.join(targetDir, "AGENTS.md"));
+    const agentsMdPath = formatPath(path12.join(targetDir, "AGENTS.md"));
     if (result.agentsMd.merged) {
       const label = context.commandName === "sync" ? "(updated)" : "(merged)";
       console.log(`  ${pc5.green("+")} ${agentsMdPath} ${pc5.dim(label)}`);
@@ -1800,7 +1862,7 @@ async function performSync(options) {
     for (const targetResult of result.targets) {
       const config = getTargetConfig(targetResult.target);
       if (config.instructionsFile) {
-        const instructionsPath = targetResult.instructionsMd.location === "root" ? formatPath(path11.join(targetDir, config.instructionsFile)) : formatPath(path11.join(targetDir, config.dir, config.instructionsFile));
+        const instructionsPath = targetResult.instructionsMd.location === "root" ? formatPath(path12.join(targetDir, config.instructionsFile)) : formatPath(path12.join(targetDir, config.dir, config.instructionsFile));
         if (targetResult.instructionsMd.created) {
           console.log(`  ${pc5.green("+")} ${instructionsPath} ${pc5.dim("(created)")}`);
         } else if (targetResult.instructionsMd.updated) {
@@ -1810,13 +1872,13 @@ async function performSync(options) {
           console.log(`  ${pc5.dim("-")} ${instructionsPath} ${pc5.dim("(unchanged)")}`);
         }
       }
-      const skillsPath = formatPath(path11.join(targetDir, config.dir, "skills"));
+      const skillsPath = formatPath(path12.join(targetDir, config.dir, "skills"));
       console.log(
         `  ${pc5.green("+")} ${skillsPath}/ ${pc5.dim(`(${result.skills.synced.length} skills, ${targetResult.skills.copied} files)`)}`
       );
       if (orphanResult.deleted.length > 0) {
         for (const skill of orphanResult.deleted) {
-          const orphanPath = formatPath(path11.join(targetDir, config.dir, "skills", skill));
+          const orphanPath = formatPath(path12.join(targetDir, config.dir, "skills", skill));
           console.log(
             `  ${pc5.red("-")} ${orphanPath}/ ${pc5.dim("(removed - no longer in source)")}`
           );
@@ -1824,28 +1886,28 @@ async function performSync(options) {
       }
       if (orphanResult.skipped.length > 0) {
         for (const skill of orphanResult.skipped) {
-          const orphanPath = formatPath(path11.join(targetDir, config.dir, "skills", skill));
+          const orphanPath = formatPath(path12.join(targetDir, config.dir, "skills", skill));
           console.log(`  ${pc5.yellow("!")} ${orphanPath}/ ${pc5.dim("(orphaned but skipped)")}`);
         }
       }
     }
     if (workflowResult) {
       for (const filename of workflowResult.created) {
-        const workflowPath = formatPath(path11.join(targetDir, ".github/workflows", filename));
+        const workflowPath = formatPath(path12.join(targetDir, ".github/workflows", filename));
         console.log(`  ${pc5.green("+")} ${workflowPath} ${pc5.dim("(created)")}`);
       }
       for (const filename of workflowResult.updated) {
-        const workflowPath = formatPath(path11.join(targetDir, ".github/workflows", filename));
+        const workflowPath = formatPath(path12.join(targetDir, ".github/workflows", filename));
         console.log(`  ${pc5.yellow("~")} ${workflowPath} ${pc5.dim("(updated)")}`);
       }
       for (const filename of workflowResult.unchanged) {
-        const workflowPath = formatPath(path11.join(targetDir, ".github/workflows", filename));
+        const workflowPath = formatPath(path12.join(targetDir, ".github/workflows", filename));
         console.log(`  ${pc5.dim("-")} ${workflowPath} ${pc5.dim("(unchanged)")}`);
       }
     }
-    const lockfilePath = formatPath(path11.join(targetDir, ".agent-conf", "agent-conf.lock"));
+    const lockfilePath = formatPath(path12.join(targetDir, ".agent-conf", "agent-conf.lock"));
     console.log(`  ${pc5.green("+")} ${lockfilePath}`);
-    const hookPath = formatPath(path11.join(targetDir, ".git/hooks/pre-commit"));
+    const hookPath = formatPath(path12.join(targetDir, ".git/hooks/pre-commit"));
     if (hookResult.installed) {
       if (hookResult.alreadyExisted && !hookResult.wasUpdated) {
         console.log(`  ${pc5.dim("-")} ${hookPath} ${pc5.dim("(unchanged)")}`);
@@ -1915,8 +1977,8 @@ async function initCommand(options) {
 }
 
 // src/commands/init-canonical-repo.ts
-import * as fs11 from "fs/promises";
-import * as path12 from "path";
+import * as fs12 from "fs/promises";
+import * as path13 from "path";
 import * as prompts5 from "@clack/prompts";
 import pc7 from "picocolors";
 import { stringify as stringifyYaml } from "yaml";
@@ -2217,8 +2279,8 @@ async function initCanonicalRepoCommand(options) {
   const logger = createLogger();
   console.log();
   prompts5.intro(pc7.bold("agent-conf init-canonical-repo"));
-  const targetDir = options.dir ? path12.resolve(options.dir) : process.cwd();
-  const dirName = path12.basename(targetDir);
+  const targetDir = options.dir ? path13.resolve(options.dir) : process.cwd();
+  const dirName = path13.basename(targetDir);
   const cwd = process.cwd();
   let isAtGitRoot = await isGitRoot(targetDir);
   let gitProjectName = await getGitProjectName(targetDir);
@@ -2227,7 +2289,7 @@ async function initCanonicalRepoCommand(options) {
     const cwdIsGitRoot = await isGitRoot(cwd);
     const cwdGitProjectName = await getGitProjectName(cwd);
     const cwdGitOrganization = await getGitOrganization(cwd);
-    if (cwdIsGitRoot && path12.resolve(targetDir) === path12.resolve(cwd)) {
+    if (cwdIsGitRoot && path13.resolve(targetDir) === path13.resolve(cwd)) {
       isAtGitRoot = true;
       gitProjectName = cwdGitProjectName;
       gitOrganization = cwdGitOrganization;
@@ -2246,7 +2308,7 @@ async function initCanonicalRepoCommand(options) {
   }
   const dirExists = await directoryExists(targetDir);
   if (dirExists) {
-    const configExists = await fileExists(path12.join(targetDir, "agent-conf.yaml"));
+    const configExists = await fileExists(path13.join(targetDir, "agent-conf.yaml"));
     if (configExists && !options.yes) {
       const shouldContinue = await prompts5.confirm({
         message: "This directory already has an agent-conf.yaml. Overwrite?",
@@ -2328,34 +2390,34 @@ async function initCanonicalRepoCommand(options) {
   spinner.start();
   try {
     await ensureDir(resolvedOptions.targetDir);
-    const instructionsDir = path12.join(resolvedOptions.targetDir, "instructions");
-    const skillsDir = path12.join(resolvedOptions.targetDir, "skills");
-    const workflowsDir = path12.join(resolvedOptions.targetDir, ".github", "workflows");
+    const instructionsDir = path13.join(resolvedOptions.targetDir, "instructions");
+    const skillsDir = path13.join(resolvedOptions.targetDir, "skills");
+    const workflowsDir = path13.join(resolvedOptions.targetDir, ".github", "workflows");
     await ensureDir(instructionsDir);
     await ensureDir(skillsDir);
     await ensureDir(workflowsDir);
-    const configPath = path12.join(resolvedOptions.targetDir, "agent-conf.yaml");
-    await fs11.writeFile(configPath, generateConfigYaml(resolvedOptions), "utf-8");
-    const agentsMdPath = path12.join(instructionsDir, "AGENTS.md");
-    await fs11.writeFile(agentsMdPath, generateAgentsMd(resolvedOptions), "utf-8");
+    const configPath = path13.join(resolvedOptions.targetDir, "agent-conf.yaml");
+    await fs12.writeFile(configPath, generateConfigYaml(resolvedOptions), "utf-8");
+    const agentsMdPath = path13.join(instructionsDir, "AGENTS.md");
+    await fs12.writeFile(agentsMdPath, generateAgentsMd(resolvedOptions), "utf-8");
     if (resolvedOptions.includeExamples) {
-      const exampleSkillDir = path12.join(skillsDir, "example-skill");
-      const referencesDir = path12.join(exampleSkillDir, "references");
+      const exampleSkillDir = path13.join(skillsDir, "example-skill");
+      const referencesDir = path13.join(exampleSkillDir, "references");
       await ensureDir(referencesDir);
-      const skillMdPath = path12.join(exampleSkillDir, "SKILL.md");
-      await fs11.writeFile(skillMdPath, generateExampleSkillMd(), "utf-8");
-      const gitkeepPath = path12.join(referencesDir, ".gitkeep");
-      await fs11.writeFile(gitkeepPath, "", "utf-8");
+      const skillMdPath = path13.join(exampleSkillDir, "SKILL.md");
+      await fs12.writeFile(skillMdPath, generateExampleSkillMd(), "utf-8");
+      const gitkeepPath = path13.join(referencesDir, ".gitkeep");
+      await fs12.writeFile(gitkeepPath, "", "utf-8");
     }
-    const syncWorkflowPath = path12.join(workflowsDir, "sync-reusable.yml");
-    const checkWorkflowPath = path12.join(workflowsDir, "check-reusable.yml");
+    const syncWorkflowPath = path13.join(workflowsDir, "sync-reusable.yml");
+    const checkWorkflowPath = path13.join(workflowsDir, "check-reusable.yml");
     const repoFullName = resolvedOptions.organization ? `${resolvedOptions.organization}/${resolvedOptions.name}` : resolvedOptions.name;
-    await fs11.writeFile(
+    await fs12.writeFile(
       syncWorkflowPath,
       generateSyncWorkflow2(repoFullName, resolvedOptions.markerPrefix),
       "utf-8"
     );
-    await fs11.writeFile(
+    await fs12.writeFile(
       checkWorkflowPath,
       generateCheckWorkflow2(repoFullName, resolvedOptions.markerPrefix),
       "utf-8"
@@ -2367,7 +2429,7 @@ async function initCanonicalRepoCommand(options) {
     console.log(`  ${pc7.green("+")} ${formatPath(agentsMdPath)}`);
     if (resolvedOptions.includeExamples) {
       console.log(
-        `  ${pc7.green("+")} ${formatPath(path12.join(skillsDir, "example-skill/SKILL.md"))}`
+        `  ${pc7.green("+")} ${formatPath(path13.join(skillsDir, "example-skill/SKILL.md"))}`
       );
     }
     console.log(`  ${pc7.green("+")} ${formatPath(syncWorkflowPath)}`);
@@ -2398,7 +2460,7 @@ async function initCanonicalRepoCommand(options) {
 }
 
 // src/commands/status.ts
-import * as path13 from "path";
+import * as path14 from "path";
 import pc8 from "picocolors";
 async function statusCommand(options = {}) {
   const targetDir = process.cwd();
@@ -2451,7 +2513,7 @@ async function statusCommand(options = {}) {
     }
     console.log();
   }
-  const lockfilePath = formatPath(path13.join(targetDir, ".agent-conf", "agent-conf.lock"));
+  const lockfilePath = formatPath(path14.join(targetDir, ".agent-conf", "agent-conf.lock"));
   console.log(pc8.dim(`Lock file: ${lockfilePath}`));
   console.log(pc8.dim(`CLI version: ${lockfile.cli_version}`));
   console.log();