agconf 0.2.0

package/dist/index.js

@@ -0,0 +1,3521 @@
+#!/usr/bin/env node
+import {
+  CURRENT_CONFIG_VERSION,
+  CanonicalRepoConfigSchema,
+  addManagedMetadata,
+  buildAgentsMd,
+  checkAllManagedFiles,
+  computeContentHash,
+  computeGlobalBlockHash,
+  computeRulesSectionHash,
+  extractRepoBlockContent,
+  getModifiedManagedFiles,
+  parseAgentsMd,
+  parseFrontmatter,
+  parseGlobalBlockMetadata,
+  parseRulesSection,
+  parseRulesSectionMetadata,
+  stripMetadataComments,
+  stripRulesSectionMetadata,
+  validateSkillFrontmatter
+} from "./chunk-B53WKCQU.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import pc11 from "picocolors";
+
+// src/commands/canonical.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import * as prompts from "@clack/prompts";
+import pc2 from "picocolors";
+import { stringify as stringifyYaml } from "yaml";
+
+// src/utils/fs.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat4 = await fs.stat(dirPath);
+    return stat4.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function createTempDir(prefix = "agent-conf-") {
+  const tmpDir = os.tmpdir();
+  return fs.mkdtemp(path.join(tmpDir, prefix));
+}
+async function removeTempDir(dirPath) {
+  try {
+    await fs.rm(dirPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+function resolvePath(inputPath) {
+  if (inputPath.startsWith("~")) {
+    return path.join(os.homedir(), inputPath.slice(1));
+  }
+  return path.resolve(inputPath);
+}
+
+// src/utils/git.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { simpleGit } from "simple-git";
+async function directoryExistsForGit(dir) {
+  try {
+    const stat4 = await fs2.stat(dir);
+    return stat4.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function getGitRoot(dir) {
+  if (!await directoryExistsForGit(dir)) {
+    return null;
+  }
+  try {
+    const git = simpleGit(dir);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return null;
+    }
+    const root = await git.revparse(["--show-toplevel"]);
+    return root.trim();
+  } catch {
+    return null;
+  }
+}
+async function getGitProjectName(dir) {
+  const gitRoot = await getGitRoot(dir);
+  if (!gitRoot) {
+    return null;
+  }
+  return path2.basename(gitRoot);
+}
+async function isGitRoot(dir) {
+  if (!await directoryExistsForGit(dir)) {
+    return false;
+  }
+  const gitRoot = await getGitRoot(dir);
+  if (!gitRoot) {
+    return false;
+  }
+  try {
+    const realDir = await fs2.realpath(dir);
+    const realGitRoot = await fs2.realpath(gitRoot);
+    return realDir === realGitRoot;
+  } catch {
+    return path2.resolve(dir) === path2.resolve(gitRoot);
+  }
+}
+async function getGitOrganization(dir) {
+  if (!await directoryExistsForGit(dir)) {
+    return void 0;
+  }
+  try {
+    const git = simpleGit(dir);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return void 0;
+    }
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    if (origin?.refs.fetch) {
+      const url = origin.refs.fetch;
+      const httpsMatch = url.match(/github\.com\/([^/]+)\//);
+      const sshMatch = url.match(/github\.com:([^/]+)\//);
+      const org = httpsMatch?.[1] ?? sshMatch?.[1];
+      if (org) {
+        return org;
+      }
+    }
+    const userName = await git.getConfig("user.name");
+    return userName.value ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utils/logger.ts
+import ora from "ora";
+import pc from "picocolors";
+function createLogger(quiet = false) {
+  return {
+    info(message) {
+      if (!quiet) {
+        console.log(`${pc.blue("info")} ${message}`);
+      }
+    },
+    success(message) {
+      if (!quiet) {
+        console.log(`${pc.green("success")} ${message}`);
+      }
+    },
+    warn(message) {
+      console.log(`${pc.yellow("warn")} ${message}`);
+    },
+    error(message) {
+      console.error(`${pc.red("error")} ${message}`);
+    },
+    dim(message) {
+      if (!quiet) {
+        console.log(pc.dim(message));
+      }
+    },
+    spinner(text2) {
+      if (quiet) {
+        return ora({ text: text2, isSilent: true });
+      }
+      return ora({ text: text2, color: "blue" });
+    }
+  };
+}
+function formatPath(p, cwd = process.cwd()) {
+  if (p.startsWith(cwd)) {
+    return `.${p.slice(cwd.length)}`;
+  }
+  return p;
+}
+
+// src/commands/canonical.ts
+function generateConfigYaml(options) {
+  const content = {
+    instructions: "instructions/AGENTS.md",
+    skills_dir: "skills"
+  };
+  if (options.rulesDir) {
+    content.rules_dir = options.rulesDir;
+  }
+  const config = {
+    version: CURRENT_CONFIG_VERSION,
+    meta: {
+      name: options.name
+    },
+    content,
+    targets: ["claude"],
+    markers: {
+      prefix: options.markerPrefix
+    },
+    merge: {
+      preserve_repo_content: true
+    }
+  };
+  if (options.organization) {
+    config.meta.organization = options.organization;
+  }
+  let yaml = stringifyYaml(config, { lineWidth: 0 });
+  if (!options.rulesDir) {
+    yaml = yaml.replace(/skills_dir: skills\n/, "skills_dir: skills\n  # rules_dir: rules\n");
+  }
+  return yaml;
+}
+function generateAgentsMd(options) {
+  const orgName = options.organization ?? "Your Organization";
+  return `# ${orgName} Engineering Standards for AI Agents
+
+This document defines company-wide engineering standards that all AI coding agents must follow.
+
+## Purpose
+
+These standards ensure consistency, maintainability, and operational excellence across all engineering projects.
+
+---
+
+## Development Principles
+
+### Code Quality
+
+- Write clean, readable code with meaningful names
+- Follow existing patterns in the codebase
+- Keep functions small and focused
+- Add comments only when the "why" isn't obvious
+
+### Testing
+
+- Write tests for new functionality
+- Ensure tests are deterministic and fast
+- Use descriptive test names
+
+---
+
+## Getting Started
+
+Add your organization's specific engineering standards below.
+
+---
+
+**Version**: 1.0
+**Last Updated**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+`;
+}
+function generateExampleSkillMd() {
+  return `---
+name: example-skill
+description: An example skill demonstrating the skill format
+---
+
+# Example Skill
+
+This is an example skill that demonstrates the skill format.
+
+## When to Use
+
+Use this skill when you need an example of how skills are structured.
+
+## Instructions
+
+1. Skills are defined in their own directories under \`skills/\`
+2. Each skill has a \`SKILL.md\` file with frontmatter
+3. The frontmatter must include \`name\` and \`description\`
+4. Optional: Include a \`references/\` directory for additional files
+
+## Example
+
+\`\`\`
+skills/
+  example-skill/
+    SKILL.md
+    references/
+      .gitkeep
+\`\`\`
+`;
+}
+function generateSyncWorkflow(repoFullName, prefix) {
+  return `# ${prefix} Auto-Sync Workflow (Reusable)
+# This workflow is called by downstream repositories.
+#
+# Downstream repos will reference this workflow like:
+#   uses: ${repoFullName}/.github/workflows/sync-reusable.yml@v1.0.0
+#
+# TOKEN: Requires a token with read access to the canonical repository.
+# The default GITHUB_TOKEN is used for operations on the downstream repo.
+
+name: Sync Reusable
+
+on:
+  workflow_call:
+    inputs:
+      force:
+        description: 'Force sync even if no updates detected'
+        required: false
+        default: false
+        type: boolean
+      commit_strategy:
+        description: 'How to commit changes: "pr" (create pull request) or "direct" (commit to current branch)'
+        required: false
+        default: 'pr'
+        type: string
+      pr_branch_prefix:
+        description: 'Branch prefix for PR branches'
+        required: false
+        default: '${prefix}/sync'
+        type: string
+      pr_title:
+        description: 'Pull request title'
+        required: false
+        default: 'chore(${prefix}): sync agent configuration'
+        type: string
+      reviewers:
+        description: 'PR reviewers (comma-separated GitHub usernames)'
+        required: false
+        type: string
+      commit_message:
+        description: 'Commit message for direct commits'
+        required: false
+        default: 'chore(${prefix}): sync agent configuration'
+        type: string
+    secrets:
+      token:
+        description: 'GitHub token with read access to the canonical repository'
+        required: true
+    outputs:
+      changes_detected:
+        description: 'Whether changes were detected after sync'
+        value: \${{ jobs.sync.outputs.changes_detected }}
+      pr_number:
+        description: 'Pull request number (if PR strategy and changes detected)'
+        value: \${{ jobs.sync.outputs.pr_number }}
+      pr_url:
+        description: 'Pull request URL (if PR strategy and changes detected)'
+        value: \${{ jobs.sync.outputs.pr_url }}
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    outputs:
+      changes_detected: \${{ steps.check-changes.outputs.changes_detected }}
+      pr_number: \${{ steps.create-pr.outputs.pr_number }}
+      pr_url: \${{ steps.create-pr.outputs.pr_url }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install agent-conf CLI
+        run: npm install -g agent-conf
+
+      - name: Run sync
+        run: agent-conf sync --yes --summary-file /tmp/sync-summary.md --expand-changes
+        env:
+          GITHUB_TOKEN: \${{ secrets.token }}
+
+      - name: Check for changes
+        id: check-changes
+        run: |
+          # Check for meaningful changes (excluding lockfile which always updates with synced_at)
+          LOCKFILE_PATH=".agent-conf/lockfile.json"
+
+          # Get changed files excluding lockfile
+          MEANINGFUL_CHANGES=$(git status --porcelain | grep -v "^.. $LOCKFILE_PATH$" || true)
+
+          if [ -n "$MEANINGFUL_CHANGES" ]; then
+            echo "changes_detected=true" >> $GITHUB_OUTPUT
+            echo "Meaningful changes detected after sync:"
+            git status --short
+          else
+            echo "changes_detected=false" >> $GITHUB_OUTPUT
+            echo "No meaningful changes detected (only lockfile updated)"
+          fi
+
+      - name: Configure git
+        if: steps.check-changes.outputs.changes_detected == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Check for existing PR
+        id: check-pr
+        if: steps.check-changes.outputs.changes_detected == 'true' && inputs.commit_strategy == 'pr'
+        env:
+          GH_TOKEN: \${{ github.token }}
+        run: |
+          BRANCH_NAME="\${{ inputs.pr_branch_prefix }}"
+
+          # Check if there's an existing open PR from this branch
+          EXISTING_PR=$(gh pr list --head "$BRANCH_NAME" --state open --json number,url --jq '.[0]' 2>/dev/null || echo "")
+
+          if [ -n "$EXISTING_PR" ] && [ "$EXISTING_PR" != "null" ]; then
+            PR_NUMBER=$(echo "$EXISTING_PR" | jq -r '.number')
+            PR_URL=$(echo "$EXISTING_PR" | jq -r '.url')
+            echo "existing_pr=true" >> $GITHUB_OUTPUT
+            echo "pr_number=$PR_NUMBER" >> $GITHUB_OUTPUT
+            echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
+            echo "Found existing PR #$PR_NUMBER: $PR_URL"
+          else
+            echo "existing_pr=false" >> $GITHUB_OUTPUT
+            echo "No existing PR found for branch $BRANCH_NAME"
+          fi
+
+          echo "BRANCH_NAME=$BRANCH_NAME" >> $GITHUB_ENV
+
+      - name: Create or update PR branch
+        if: steps.check-changes.outputs.changes_detected == 'true' && inputs.commit_strategy == 'pr'
+        run: |
+          BRANCH_NAME="\${{ inputs.pr_branch_prefix }}"
+
+          # Check if remote branch exists
+          if git ls-remote --exit-code --heads origin "$BRANCH_NAME" >/dev/null 2>&1; then
+            # Branch exists - fetch and reset to it, then apply our changes
+            git fetch origin "$BRANCH_NAME"
+            git checkout -B "$BRANCH_NAME" origin/"$BRANCH_NAME"
+            # Reset to match the base branch, then apply changes
+            git reset --soft \${{ github.ref_name }}
+          else
+            # Create new branch
+            git checkout -b "$BRANCH_NAME"
+          fi
+
+          git add -A
+          git commit -m "\${{ inputs.pr_title }}" || echo "No changes to commit"
+          git push --force-with-lease -u origin "$BRANCH_NAME"
+
+      - name: Create or update pull request
+        id: create-pr
+        if: steps.check-changes.outputs.changes_detected == 'true' && inputs.commit_strategy == 'pr'
+        env:
+          GH_TOKEN: \${{ github.token }}
+        run: |
+          # Read sync summary if available
+          if [ -f /tmp/sync-summary.md ]; then
+            SYNC_SUMMARY=$(cat /tmp/sync-summary.md)
+          else
+            SYNC_SUMMARY="## Changes
+          - Synced agent configuration from canonical repository"
+          fi
+
+          PR_BODY="This PR was automatically created by the ${prefix} sync workflow.
+
+          $SYNC_SUMMARY
+
+          ---
+          *This is an automated PR. Review the changes and merge when ready.*"
+
+          if [ "\${{ steps.check-pr.outputs.existing_pr }}" == "true" ]; then
+            # Update existing PR body
+            PR_NUMBER="\${{ steps.check-pr.outputs.pr_number }}"
+            PR_URL="\${{ steps.check-pr.outputs.pr_url }}"
+
+            gh pr edit "$PR_NUMBER" --body "$PR_BODY"
+            echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
+            echo "pr_number=$PR_NUMBER" >> $GITHUB_OUTPUT
+            echo "Updated existing PR #$PR_NUMBER: $PR_URL"
+          else
+            # Create new PR
+            REVIEWERS_ARG=""
+            if [ -n "\${{ inputs.reviewers }}" ]; then
+              REVIEWERS_ARG="--reviewer \${{ inputs.reviewers }}"
+            fi
+
+            PR_URL=$(gh pr create \\
+              --title "\${{ inputs.pr_title }}" \\
+              --body "$PR_BODY" \\
+              $REVIEWERS_ARG)
+
+            PR_NUMBER=$(gh pr view --json number -q .number)
+            echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
+            echo "pr_number=$PR_NUMBER" >> $GITHUB_OUTPUT
+            echo "Created PR #$PR_NUMBER: $PR_URL"
+          fi
+
+      - name: Commit directly to branch
+        if: steps.check-changes.outputs.changes_detected == 'true' && inputs.commit_strategy == 'direct'
+        run: |
+          git add -A
+          git commit -m "\${{ inputs.commit_message }}"
+          git push
+          echo "Changes committed directly to $(git branch --show-current)"
+`;
+}
+function generateCheckWorkflow(repoFullName, prefix) {
+  return `# ${prefix} File Integrity Check (Reusable)
+# This workflow is called by downstream repositories.
+#
+# Downstream repos will reference this workflow like:
+#   uses: ${repoFullName}/.github/workflows/check-reusable.yml@v1.0.0
+
+name: Check Reusable
+
+on:
+  workflow_call:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install agent-conf CLI
+        run: npm install -g agent-conf
+
+      - name: Check file integrity
+        run: agent-conf check
+`;
+}
+async function canonicalInitCommand(options) {
+  const logger = createLogger();
+  console.log();
+  prompts.intro(pc2.bold("agent-conf canonical init"));
+  const targetDir = options.dir ? path3.resolve(options.dir) : process.cwd();
+  const dirName = path3.basename(targetDir);
+  const cwd = process.cwd();
+  let isAtGitRoot = await isGitRoot(targetDir);
+  let gitProjectName = await getGitProjectName(targetDir);
+  let gitOrganization = await getGitOrganization(targetDir);
+  if (!gitProjectName) {
+    const cwdIsGitRoot = await isGitRoot(cwd);
+    const cwdGitProjectName = await getGitProjectName(cwd);
+    const cwdGitOrganization = await getGitOrganization(cwd);
+    if (cwdIsGitRoot && path3.resolve(targetDir) === path3.resolve(cwd)) {
+      isAtGitRoot = true;
+      gitProjectName = cwdGitProjectName;
+      gitOrganization = cwdGitOrganization;
+    } else if (cwdGitOrganization && !gitOrganization) {
+      gitOrganization = cwdGitOrganization;
+    }
+  }
+  let defaultName;
+  let nameHint;
+  if (isAtGitRoot && gitProjectName) {
+    defaultName = gitProjectName;
+    nameHint = " (from current git project)";
+  } else {
+    defaultName = dirName;
+    nameHint = "";
+  }
+  const dirExists = await directoryExists(targetDir);
+  if (dirExists) {
+    const configExists = await fileExists(path3.join(targetDir, "agent-conf.yaml"));
+    if (configExists && !options.yes) {
+      const shouldContinue = await prompts.confirm({
+        message: "This directory already has an agent-conf.yaml. Overwrite?",
+        initialValue: false
+      });
+      if (prompts.isCancel(shouldContinue) || !shouldContinue) {
+        prompts.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+  }
+  let resolvedOptions;
+  if (options.yes) {
+    resolvedOptions = {
+      name: options.name ?? defaultName,
+      organization: options.org ?? gitOrganization,
+      targetDir,
+      markerPrefix: options.markerPrefix ?? "agent-conf",
+      includeExamples: options.includeExamples !== false,
+      rulesDir: options.rulesDir || void 0
+    };
+  } else {
+    const name = await prompts.text({
+      message: `Canonical repository name${nameHint}:`,
+      placeholder: defaultName,
+      defaultValue: options.name ?? defaultName,
+      validate: (value) => {
+        if (!value.trim()) return "Name is required";
+        if (!/^[a-z0-9-]+$/.test(value)) return "Name must be lowercase alphanumeric with hyphens";
+        return void 0;
+      }
+    });
+    if (prompts.isCancel(name)) {
+      prompts.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const orgDefault = options.org ?? gitOrganization;
+    const orgHint = gitOrganization && !options.org ? " (from git)" : "";
+    const organization = await prompts.text({
+      message: `Organization name${orgHint} (optional):`,
+      placeholder: orgDefault ?? "ACME Corp",
+      ...orgDefault ? { defaultValue: orgDefault } : {}
+    });
+    if (prompts.isCancel(organization)) {
+      prompts.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const markerPrefix = await prompts.text({
+      message: "Marker prefix for managed content:",
+      placeholder: "agent-conf",
+      defaultValue: options.markerPrefix ?? "agent-conf",
+      validate: (value) => {
+        if (!value.trim()) return "Prefix is required";
+        if (!/^[a-z0-9-]+$/.test(value))
+          return "Prefix must be lowercase alphanumeric with hyphens";
+        return void 0;
+      }
+    });
+    if (prompts.isCancel(markerPrefix)) {
+      prompts.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const includeExamples = await prompts.confirm({
+      message: "Include example skill?",
+      initialValue: options.includeExamples !== false
+    });
+    if (prompts.isCancel(includeExamples)) {
+      prompts.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const includeRules = await prompts.confirm({
+      message: "Include rules directory?",
+      initialValue: false
+    });
+    if (prompts.isCancel(includeRules)) {
+      prompts.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    let rulesDir;
+    if (includeRules) {
+      const rulesDirInput = await prompts.text({
+        message: "Rules directory name:",
+        placeholder: "rules",
+        defaultValue: "rules",
+        validate: (value) => {
+          if (!value.trim()) return "Directory name is required";
+          if (!/^[a-z0-9-_/]+$/.test(value))
+            return "Directory name must be lowercase alphanumeric with hyphens, underscores, or slashes";
+          return void 0;
+        }
+      });
+      if (prompts.isCancel(rulesDirInput)) {
+        prompts.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      rulesDir = rulesDirInput;
+    }
+    resolvedOptions = {
+      name,
+      organization: organization || void 0,
+      targetDir,
+      markerPrefix,
+      includeExamples,
+      rulesDir
+    };
+  }
+  const spinner = logger.spinner("Creating canonical repository structure...");
+  spinner.start();
+  try {
+    await ensureDir(resolvedOptions.targetDir);
+    const instructionsDir = path3.join(resolvedOptions.targetDir, "instructions");
+    const skillsDir = path3.join(resolvedOptions.targetDir, "skills");
+    const workflowsDir = path3.join(resolvedOptions.targetDir, ".github", "workflows");
+    await ensureDir(instructionsDir);
+    await ensureDir(skillsDir);
+    await ensureDir(workflowsDir);
+    if (resolvedOptions.rulesDir) {
+      const rulesDir = path3.join(resolvedOptions.targetDir, resolvedOptions.rulesDir);
+      await ensureDir(rulesDir);
+      await fs3.writeFile(path3.join(rulesDir, ".gitkeep"), "", "utf-8");
+    }
+    const configPath = path3.join(resolvedOptions.targetDir, "agent-conf.yaml");
+    await fs3.writeFile(configPath, generateConfigYaml(resolvedOptions), "utf-8");
+    const agentsMdPath = path3.join(instructionsDir, "AGENTS.md");
+    await fs3.writeFile(agentsMdPath, generateAgentsMd(resolvedOptions), "utf-8");
+    if (resolvedOptions.includeExamples) {
+      const exampleSkillDir = path3.join(skillsDir, "example-skill");
+      const referencesDir = path3.join(exampleSkillDir, "references");
+      await ensureDir(referencesDir);
+      const skillMdPath = path3.join(exampleSkillDir, "SKILL.md");
+      await fs3.writeFile(skillMdPath, generateExampleSkillMd(), "utf-8");
+      const gitkeepPath = path3.join(referencesDir, ".gitkeep");
+      await fs3.writeFile(gitkeepPath, "", "utf-8");
+    }
+    const syncWorkflowPath = path3.join(workflowsDir, "sync-reusable.yml");
+    const checkWorkflowPath = path3.join(workflowsDir, "check-reusable.yml");
+    const repoFullName = resolvedOptions.organization ? `${resolvedOptions.organization}/${resolvedOptions.name}` : resolvedOptions.name;
+    await fs3.writeFile(
+      syncWorkflowPath,
+      generateSyncWorkflow(repoFullName, resolvedOptions.markerPrefix),
+      "utf-8"
+    );
+    await fs3.writeFile(
+      checkWorkflowPath,
+      generateCheckWorkflow(repoFullName, resolvedOptions.markerPrefix),
+      "utf-8"
+    );
+    spinner.succeed("Canonical repository structure created");
+    console.log();
+    console.log(pc2.bold("Created:"));
+    console.log(`  ${pc2.green("+")} ${formatPath(configPath)}`);
+    console.log(`  ${pc2.green("+")} ${formatPath(agentsMdPath)}`);
+    if (resolvedOptions.includeExamples) {
+      console.log(
+        `  ${pc2.green("+")} ${formatPath(path3.join(skillsDir, "example-skill/SKILL.md"))}`
+      );
+    }
+    if (resolvedOptions.rulesDir) {
+      console.log(
+        `  ${pc2.green("+")} ${formatPath(path3.join(resolvedOptions.targetDir, resolvedOptions.rulesDir))}/`
+      );
+    }
+    console.log(`  ${pc2.green("+")} ${formatPath(syncWorkflowPath)}`);
+    console.log(`  ${pc2.green("+")} ${formatPath(checkWorkflowPath)}`);
+    console.log();
+    console.log(pc2.dim(`Name: ${resolvedOptions.name}`));
+    if (resolvedOptions.organization) {
+      console.log(pc2.dim(`Organization: ${resolvedOptions.organization}`));
+    }
+    console.log(pc2.dim(`Marker prefix: ${resolvedOptions.markerPrefix}`));
+    console.log();
+    console.log(pc2.bold("Next steps:"));
+    console.log(`  1. Edit ${pc2.cyan("instructions/AGENTS.md")} with your engineering standards`);
+    console.log(`  2. Add skills to ${pc2.cyan("skills/")} directory`);
+    if (resolvedOptions.rulesDir) {
+      console.log(`  3. Add rules to ${pc2.cyan(`${resolvedOptions.rulesDir}/`)} directory`);
+      console.log(`  4. Commit and push to create your canonical repository`);
+    } else {
+      console.log(`  3. Commit and push to create your canonical repository`);
+    }
+    console.log();
+    console.log(
+      pc2.dim(
+        `See https://github.com/julian-pani/agent-conf/blob/master/cli/docs/CANONICAL_REPOSITORY_SETUP.md for detailed setup instructions.`
+      )
+    );
+    prompts.outro(pc2.green("Done!"));
+  } catch (error) {
+    spinner.fail("Failed to create canonical repository");
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/check.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import pc3 from "picocolors";
+
+// src/core/lockfile.ts
+import { createHash } from "crypto";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+
+// src/schemas/lockfile.ts
+import { z } from "zod";
+var CURRENT_LOCKFILE_VERSION = "1.0.0";
+var RulesContentSchema = z.object({
+  /** List of rule file paths synced (relative to rules dir) */
+  files: z.array(z.string()),
+  /** Hash of all rules content */
+  content_hash: z.string()
+});
+var SourceSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("github"),
+    repository: z.string(),
+    commit_sha: z.string(),
+    ref: z.string()
+  }),
+  z.object({
+    type: z.literal("local"),
+    path: z.string(),
+    commit_sha: z.string().optional()
+  })
+]);
+var ContentSchema = z.object({
+  agents_md: z.object({
+    global_block_hash: z.string(),
+    merged: z.boolean()
+  }),
+  skills: z.array(z.string()),
+  targets: z.array(z.string()).optional(),
+  /** Marker prefix used for managed content (default: "agent-conf") */
+  marker_prefix: z.string().optional(),
+  /** Rules content tracking - optional for backward compat */
+  rules: RulesContentSchema.optional()
+});
+var LockfileSchema = z.object({
+  /** Schema version in semver format (e.g., "1.0.0") */
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Version must be in semver format (e.g., 1.0.0)"),
+  /** Pinned release version of the canonical source (e.g., "1.2.0") */
+  pinned_version: z.string().optional(),
+  synced_at: z.string().datetime(),
+  source: SourceSchema,
+  content: ContentSchema,
+  /** CLI version used for sync (optional, for diagnostics only) */
+  cli_version: z.string().optional()
+});
+
+// src/core/schema.ts
+var SUPPORTED_SCHEMA_VERSION = "1.0.0";
+function checkSchemaCompatibility(contentVersion) {
+  const contentParts = contentVersion.split(".").map(Number);
+  const supportedParts = SUPPORTED_SCHEMA_VERSION.split(".").map(Number);
+  const contentMajor = contentParts[0] ?? 0;
+  const contentMinor = contentParts[1] ?? 0;
+  const supportedMajor = supportedParts[0] ?? 0;
+  const supportedMinor = supportedParts[1] ?? 0;
+  if (contentMajor > supportedMajor) {
+    return {
+      compatible: false,
+      error: `Schema version ${contentVersion} requires a newer CLI. Run: npm install -g agent-conf@latest`
+    };
+  }
+  if (contentMajor < supportedMajor) {
+    return {
+      compatible: false,
+      error: `Schema version ${contentVersion} is outdated and no longer supported. This content was created with an older version of agent-conf.`
+    };
+  }
+  if (contentMinor > supportedMinor) {
+    return {
+      compatible: true,
+      warning: `Content uses schema ${contentVersion}, CLI supports ${SUPPORTED_SCHEMA_VERSION}. Some features may not work. Consider upgrading: npm install -g agent-conf@latest`
+    };
+  }
+  return { compatible: true };
+}
+
+// src/core/lockfile.ts
+var CONFIG_DIR = ".agent-conf";
+var LOCKFILE_NAME = "lockfile.json";
+function getLockfilePath(targetDir) {
+  return path4.join(targetDir, CONFIG_DIR, LOCKFILE_NAME);
+}
+async function readLockfile(targetDir) {
+  const lockfilePath = getLockfilePath(targetDir);
+  try {
+    const content = await fs4.readFile(lockfilePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const lockfile = LockfileSchema.parse(parsed);
+    const schemaCompatibility = checkSchemaCompatibility(lockfile.version);
+    return { lockfile, schemaCompatibility };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeLockfile(targetDir, options) {
+  const lockfilePath = getLockfilePath(targetDir);
+  const lockfile = {
+    version: CURRENT_LOCKFILE_VERSION,
+    pinned_version: options.pinnedVersion,
+    synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+    source: options.source,
+    content: {
+      agents_md: {
+        global_block_hash: hashContent(options.globalBlockContent),
+        merged: true
+      },
+      skills: options.skills,
+      targets: options.targets ?? ["claude"],
+      marker_prefix: options.markerPrefix,
+      rules: options.rules
+    },
+    cli_version: getCliVersion()
+  };
+  await fs4.mkdir(path4.dirname(lockfilePath), { recursive: true });
+  await fs4.writeFile(lockfilePath, `${JSON.stringify(lockfile, null, 2)}
+`, "utf-8");
+  return lockfile;
+}
+function hashContent(content) {
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256:${hash.slice(0, 12)}`;
+}
+function getCliVersion() {
+  return true ? "0.2.0" : "0.0.0";
+}
+async function checkCliVersionMismatch(targetDir) {
+  const result = await readLockfile(targetDir);
+  if (!result) {
+    return null;
+  }
+  const currentVersion = getCliVersion();
+  const lockfileVersion = result.lockfile.cli_version;
+  if (!currentVersion || !lockfileVersion) {
+    return null;
+  }
+  const current = currentVersion.split(".").map(Number);
+  const lockfile_ = lockfileVersion.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((lockfile_[i] || 0) > (current[i] || 0)) {
+      return {
+        currentVersion,
+        lockfileVersion
+      };
+    }
+    if ((current[i] || 0) > (lockfile_[i] || 0)) {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/commands/check.ts
+async function checkCommand(options = {}) {
+  const targetDir = process.cwd();
+  const result = await readLockfile(targetDir);
+  if (!result) {
+    if (!options.quiet) {
+      console.log();
+      console.log(pc3.yellow("Not synced"));
+      console.log();
+      console.log(pc3.dim("This repository has not been synced with agent-conf."));
+      console.log(pc3.dim("Run `agent-conf init` to sync engineering standards."));
+      console.log();
+    }
+    return;
+  }
+  const { lockfile, schemaCompatibility } = result;
+  if (!schemaCompatibility.compatible) {
+    if (!options.quiet) {
+      console.log();
+      console.log(pc3.red(`Schema error: ${schemaCompatibility.error}`));
+      console.log();
+    }
+    process.exit(1);
+  }
+  if (schemaCompatibility.warning && !options.quiet) {
+    console.log();
+    console.log(pc3.yellow(`Warning: ${schemaCompatibility.warning}`));
+    console.log();
+  }
+  const targets = lockfile.content.targets ?? ["claude"];
+  const markerPrefix = lockfile.content.marker_prefix;
+  const modifiedFiles = [];
+  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 = path5.join(targetDir, "AGENTS.md");
+      const content = await fs5.readFile(agentsMdPath, "utf-8");
+      const parsed = parseAgentsMd(content, markerPrefix ? { prefix: markerPrefix } : void 0);
+      if (parsed.globalBlock) {
+        const metadata = parseGlobalBlockMetadata(parsed.globalBlock);
+        const contentWithoutMeta = stripMetadataComments(parsed.globalBlock);
+        const currentHash = computeGlobalBlockHash(contentWithoutMeta);
+        modifiedFiles.push({
+          path: "AGENTS.md",
+          type: "agents",
+          expectedHash: metadata.contentHash ?? "unknown",
+          currentHash
+        });
+      }
+    } else if (file.type === "skill") {
+      const skillPath = path5.join(targetDir, file.path);
+      const content = await fs5.readFile(skillPath, "utf-8");
+      const { frontmatter } = parseFrontmatter(content);
+      const metadata = frontmatter.metadata;
+      const storedHash = metadata?.[`${keyPrefix}content_hash`] ?? "unknown";
+      const currentHash = computeContentHash(
+        content,
+        markerPrefix ? { metadataPrefix: markerPrefix } : void 0
+      );
+      modifiedFiles.push({
+        path: file.path,
+        type: "skill",
+        expectedHash: storedHash,
+        currentHash
+      });
+    } else if (file.type === "rule") {
+      const rulePath = path5.join(targetDir, file.path);
+      const content = await fs5.readFile(rulePath, "utf-8");
+      const { frontmatter } = parseFrontmatter(content);
+      const metadata = frontmatter.metadata;
+      const storedHash = metadata?.[`${keyPrefix}content_hash`] ?? "unknown";
+      const currentHash = computeContentHash(
+        content,
+        markerPrefix ? { metadataPrefix: markerPrefix } : void 0
+      );
+      const ruleInfo = {
+        path: file.path,
+        type: "rule",
+        expectedHash: storedHash,
+        currentHash
+      };
+      if (file.rulePath) {
+        ruleInfo.rulePath = file.rulePath;
+      }
+      modifiedFiles.push(ruleInfo);
+    } else if (file.type === "rules-section") {
+      const agentsMdPath = path5.join(targetDir, "AGENTS.md");
+      const content = await fs5.readFile(agentsMdPath, "utf-8");
+      const parsed = parseRulesSection(
+        content,
+        markerPrefix ? { prefix: markerPrefix } : void 0
+      );
+      if (parsed.content) {
+        const metadata = parseRulesSectionMetadata(parsed.content);
+        const contentWithoutMeta = stripRulesSectionMetadata(parsed.content);
+        const currentHash = computeRulesSectionHash(contentWithoutMeta);
+        modifiedFiles.push({
+          path: "AGENTS.md",
+          type: "rules-section",
+          expectedHash: metadata.contentHash ?? "unknown",
+          currentHash
+        });
+      }
+    }
+  }
+  if (allFiles.length === 0) {
+    if (options.quiet) {
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc3.bold("agent-conf check"));
+    console.log();
+    console.log(`${pc3.red("\u2717")} No managed files found`);
+    console.log();
+    console.log(pc3.dim("This repository appears to be synced but no managed files were detected."));
+    if (markerPrefix) {
+      console.log(pc3.dim(`Expected marker prefix: ${markerPrefix}`));
+    }
+    console.log(pc3.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);
+    }
+    return;
+  }
+  console.log();
+  console.log(pc3.bold("agent-conf check"));
+  console.log();
+  console.log("Checking managed files...");
+  console.log();
+  if (modifiedFiles.length === 0) {
+    console.log(`${pc3.green("\u2713")} All managed files are unchanged`);
+    console.log();
+    return;
+  }
+  console.log(`${pc3.red("\u2717")} ${modifiedFiles.length} managed file(s) have been modified:`);
+  console.log();
+  for (const file of modifiedFiles) {
+    let label = "";
+    if (file.type === "agents") {
+      label = " (global block)";
+    } else if (file.type === "rules-section") {
+      label = " (rules section)";
+    } else if (file.type === "rule" && file.rulePath) {
+      label = ` (rule: ${file.rulePath})`;
+    }
+    console.log(`  ${file.path}${pc3.dim(label)}`);
+    console.log(`    Expected hash: ${pc3.dim(file.expectedHash)}`);
+    console.log(`    Current hash:  ${pc3.dim(file.currentHash)}`);
+    console.log();
+  }
+  console.log(pc3.dim("These files are managed by agent-conf and should not be modified manually."));
+  console.log(pc3.dim("Run 'agent-conf sync' to restore them to the expected state."));
+  console.log();
+  process.exit(1);
+}
+
+// src/commands/completion.ts
+import fs6 from "fs";
+import os2 from "os";
+import path6 from "path";
+import * as prompts2 from "@clack/prompts";
+import pc4 from "picocolors";
+import tabtab from "tabtab";
+import tabtabInstaller from "tabtab/lib/installer.js";
+var CLI_NAME = "agent-conf";
+var COMMANDS = {
+  init: {
+    description: "Initialize or sync agent-conf standards",
+    options: ["-s", "--source", "--local", "-y", "--yes", "--override", "--ref", "-t", "--target"]
+  },
+  sync: {
+    description: "Sync agent-conf standards",
+    options: ["-s", "--source", "--local", "-y", "--yes", "--override", "--ref", "-t", "--target"]
+  },
+  status: {
+    description: "Show current sync status",
+    options: ["-c", "--check"]
+  },
+  update: {
+    description: "Check for and apply updates",
+    options: ["-y", "--yes", "-t", "--target"]
+  },
+  check: {
+    description: "Check if managed files have been modified",
+    options: ["-q", "--quiet"]
+  },
+  config: {
+    description: "Manage global CLI configuration",
+    options: []
+  },
+  "upgrade-cli": {
+    description: "Upgrade the CLI to latest version",
+    options: ["-y", "--yes"]
+  },
+  canonical: {
+    description: "Manage canonical repositories",
+    options: [],
+    subcommands: {
+      init: {
+        description: "Scaffold a new canonical repository",
+        options: [
+          "-n",
+          "--name",
+          "-o",
+          "--org",
+          "-d",
+          "--dir",
+          "--marker-prefix",
+          "--no-examples",
+          "--rules-dir",
+          "-y",
+          "--yes"
+        ]
+      }
+    }
+  },
+  completion: {
+    description: "Manage shell completions",
+    options: []
+  }
+};
+var CONFIG_SUBCOMMANDS = ["show", "get", "set"];
+var COMPLETION_SUBCOMMANDS = ["install", "uninstall"];
+var CANONICAL_SUBCOMMANDS = ["init"];
+var TARGET_VALUES = ["claude", "codex"];
+function handleCompletion() {
+  const env = tabtab.parseEnv(process.env);
+  if (!env.complete) {
+    return false;
+  }
+  const { prev, words } = env;
+  if (prev === CLI_NAME || words === 1) {
+    tabtab.log(
+      Object.entries(COMMANDS).map(([name, info]) => ({
+        name,
+        description: info.description
+      }))
+    );
+    return true;
+  }
+  const commandIndex = 1;
+  const currentCommand = env.line.split(/\s+/)[commandIndex];
+  if (currentCommand === "config" && words === 2) {
+    tabtab.log(
+      CONFIG_SUBCOMMANDS.map((name) => ({
+        name,
+        description: `${name} configuration`
+      }))
+    );
+    return true;
+  }
+  if (currentCommand === "completion" && words === 2) {
+    tabtab.log(
+      COMPLETION_SUBCOMMANDS.map((name) => ({
+        name,
+        description: `${name} shell completions`
+      }))
+    );
+    return true;
+  }
+  if (currentCommand === "canonical" && words === 2) {
+    tabtab.log(
+      CANONICAL_SUBCOMMANDS.map((name) => ({
+        name,
+        description: "Scaffold a new canonical repository"
+      }))
+    );
+    return true;
+  }
+  if (currentCommand === "canonical" && words >= 3) {
+    const subcommand = env.line.split(/\s+/)[2];
+    const canonicalCmd = COMMANDS.canonical;
+    if (subcommand && subcommand in canonicalCmd.subcommands) {
+      const subcommandConfig = canonicalCmd.subcommands[subcommand];
+      if (subcommandConfig) {
+        tabtab.log(subcommandConfig.options);
+        return true;
+      }
+    }
+  }
+  if (prev === "--target" || prev === "-t") {
+    tabtab.log(TARGET_VALUES);
+    return true;
+  }
+  if (currentCommand && currentCommand in COMMANDS) {
+    const command = COMMANDS[currentCommand];
+    tabtab.log(command.options);
+    return true;
+  }
+  tabtab.log(Object.keys(COMMANDS));
+  return true;
+}
+function getTabtabCompletionFile(shell) {
+  const home = os2.homedir();
+  const ext = shell === "fish" ? "fish" : shell === "zsh" ? "zsh" : "bash";
+  return path6.join(home, ".config", "tabtab", `${CLI_NAME}.${ext}`);
+}
+function isCompletionInstalled() {
+  const shell = detectShell();
+  if (!shell) return false;
+  const completionFile = getTabtabCompletionFile(shell);
+  if (fs6.existsSync(completionFile)) {
+    return true;
+  }
+  const configFile = getShellConfigFile(shell);
+  if (!configFile || !fs6.existsSync(configFile)) return false;
+  try {
+    const content = fs6.readFileSync(configFile, "utf-8");
+    return content.includes(`tabtab source for ${CLI_NAME}`) || content.includes(`begin ${CLI_NAME}`);
+  } catch {
+    return false;
+  }
+}
+function detectShell() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("fish")) return "fish";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("bash")) return "bash";
+  return null;
+}
+function getShellConfigFile(shell) {
+  const home = os2.homedir();
+  switch (shell) {
+    case "zsh":
+      return path6.join(home, ".zshrc");
+    case "bash": {
+      const bashProfile = path6.join(home, ".bash_profile");
+      if (fs6.existsSync(bashProfile)) return bashProfile;
+      return path6.join(home, ".bashrc");
+    }
+    case "fish":
+      return path6.join(home, ".config", "fish", "config.fish");
+    default:
+      return null;
+  }
+}
+async function installCompletionForShell(shell) {
+  const location = getShellConfigFile(shell);
+  if (!location) {
+    throw new Error(`Unsupported shell: ${shell}`);
+  }
+  await tabtabInstaller.install({
+    name: CLI_NAME,
+    completer: CLI_NAME,
+    location
+  });
+}
+async function installCompletion() {
+  console.log();
+  prompts2.intro(pc4.bold("Installing shell completions"));
+  const shell = detectShell();
+  if (!shell) {
+    prompts2.log.warn("Could not detect shell. Supported shells: bash, zsh, fish");
+    prompts2.outro("Completions not installed");
+    return;
+  }
+  prompts2.log.info(`Detected shell: ${pc4.cyan(shell)}`);
+  if (isCompletionInstalled()) {
+    prompts2.log.success("Shell completions are already installed");
+    prompts2.outro("Nothing to do");
+    return;
+  }
+  try {
+    await installCompletionForShell(shell);
+    prompts2.log.success(`Completions installed for ${pc4.cyan(shell)}`);
+    prompts2.log.info(
+      `Restart your shell or run: ${pc4.cyan(`source ${getShellConfigFile(shell)}`)}`
+    );
+    prompts2.outro("Done!");
+  } catch (error) {
+    prompts2.log.error(`Failed to install completions: ${error}`);
+    prompts2.outro("Installation failed");
+    process.exit(1);
+  }
+}
+async function uninstallCompletion() {
+  console.log();
+  prompts2.intro(pc4.bold("Uninstalling shell completions"));
+  try {
+    await tabtab.uninstall({
+      name: CLI_NAME
+    });
+    prompts2.log.success("Shell completions uninstalled");
+    prompts2.outro("Done!");
+  } catch (error) {
+    prompts2.log.error(`Failed to uninstall completions: ${error}`);
+    prompts2.outro("Uninstallation failed");
+    process.exit(1);
+  }
+}
+async function promptCompletionInstall() {
+  if (isCompletionInstalled()) {
+    return false;
+  }
+  const shell = detectShell();
+  if (!shell) {
+    return false;
+  }
+  const shouldInstall = await prompts2.confirm({
+    message: `Install shell completions for ${shell}?`
+  });
+  if (prompts2.isCancel(shouldInstall) || !shouldInstall) {
+    prompts2.log.info(`You can install later with: ${pc4.cyan("agent-conf completion install")}`);
+    return false;
+  }
+  try {
+    await installCompletionForShell(shell);
+    prompts2.log.success(`Completions installed for ${pc4.cyan(shell)}`);
+    prompts2.log.info(
+      `Restart your shell or run: ${pc4.cyan(`source ${getShellConfigFile(shell)}`)}`
+    );
+    return true;
+  } catch (error) {
+    prompts2.log.warn(`Could not install completions: ${error}`);
+    prompts2.log.info(`You can try again with: ${pc4.cyan("agent-conf completion install")}`);
+    return false;
+  }
+}
+
+// src/commands/config.ts
+import * as prompts3 from "@clack/prompts";
+import pc5 from "picocolors";
+async function configShowCommand() {
+  console.log();
+  prompts3.intro(pc5.bold("agent-conf config"));
+  console.log();
+  console.log(pc5.bold("Global Configuration:"));
+  console.log();
+  console.log(pc5.dim("  No configuration options available."));
+  console.log();
+  console.log(pc5.dim("Config location: ~/.agent-conf/config.json"));
+  prompts3.outro("");
+}
+async function configGetCommand(key) {
+  const logger = createLogger();
+  logger.error(`Unknown config key: ${key}`);
+  logger.info("No configuration options available.");
+  process.exit(1);
+}
+async function configSetCommand(key, _value) {
+  const logger = createLogger();
+  logger.error(`Unknown config key: ${key}`);
+  logger.info("No configuration options available.");
+  process.exit(1);
+}
+
+// src/commands/init.ts
+import * as prompts5 from "@clack/prompts";
+import pc7 from "picocolors";
+
+// src/core/sync.ts
+import { createHash as createHash3 } from "crypto";
+import * as fs8 from "fs/promises";
+import * as path8 from "path";
+import fg from "fast-glob";
+
+// src/core/merge.ts
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
+async function readFileIfExists(filePath) {
+  try {
+    return await fs7.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function gatherExistingContent(targetDir) {
+  const agentsMdPath = path7.join(targetDir, "AGENTS.md");
+  const rootClaudeMdPath = path7.join(targetDir, "CLAUDE.md");
+  const dotClaudeClaudeMdPath = path7.join(targetDir, ".claude", "CLAUDE.md");
+  const agentsMd = await readFileIfExists(agentsMdPath);
+  const rootClaudeMd = await readFileIfExists(rootClaudeMdPath);
+  if (rootClaudeMd !== null) {
+    return { agentsMd, claudeMd: rootClaudeMd, claudeMdLocation: "root" };
+  }
+  const dotClaudeClaudeMd = await readFileIfExists(dotClaudeClaudeMdPath);
+  if (dotClaudeClaudeMd !== null) {
+    return { agentsMd, claudeMd: dotClaudeClaudeMd, claudeMdLocation: "dotclaude" };
+  }
+  return { agentsMd, claudeMd: null, claudeMdLocation: null };
+}
+function stripAgentsReference(content) {
+  return content.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    return !trimmed.match(/^@(\.\.\/|\.claude\/)?AGENTS\.md$/);
+  }).join("\n").trim();
+}
+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, markerOptions);
+    if (parsed.hasMarkers) {
+      const repoContent2 = extractRepoBlockContent(parsed);
+      if (repoContent2) {
+        contentToMerge.push(repoContent2);
+      }
+    } else {
+      contentToMerge.push(existing.agentsMd.trim());
+    }
+  }
+  let claudeMdContentForMerge = null;
+  if (existing.claudeMd !== null && !options.override) {
+    const strippedContent = stripAgentsReference(existing.claudeMd);
+    if (strippedContent) {
+      claudeMdContentForMerge = strippedContent;
+      contentToMerge.push(strippedContent);
+    }
+  }
+  const repoContent = contentToMerge.length > 0 ? contentToMerge.join("\n\n") : null;
+  const content = buildAgentsMd(globalContent, repoContent, {}, markerOptions);
+  const merged = !options.override && (existing.agentsMd !== null || existing.claudeMd !== null);
+  const preservedRepoContent = contentToMerge.length > 0;
+  return {
+    content,
+    merged,
+    preservedRepoContent,
+    existingClaudeMdContent: claudeMdContentForMerge,
+    claudeMdLocation: existing.claudeMdLocation
+  };
+}
+async function writeAgentsMd(targetDir, content) {
+  const agentsMdPath = path7.join(targetDir, "AGENTS.md");
+  await fs7.writeFile(agentsMdPath, content, "utf-8");
+}
+async function ensureClaudeMd(targetDir, existingLocation) {
+  const rootPath = path7.join(targetDir, "CLAUDE.md");
+  const dotClaudePath = path7.join(targetDir, ".claude", "CLAUDE.md");
+  const rootReference = "@AGENTS.md";
+  const dotClaudeReference = "@../AGENTS.md";
+  if (existingLocation === "root") {
+    const existingContent = await readFileIfExists(rootPath);
+    if (existingContent !== null) {
+      if (existingContent.includes(rootReference)) {
+        return { created: false, updated: false, location: "root", contentMerged: false };
+      }
+      await fs7.writeFile(rootPath, `${rootReference}
+`, "utf-8");
+      return { created: false, updated: true, location: "root", contentMerged: true };
+    }
+  }
+  if (existingLocation === "dotclaude") {
+    const existingContent = await readFileIfExists(dotClaudePath);
+    if (existingContent !== null) {
+      if (existingContent.includes(dotClaudeReference)) {
+        return { created: false, updated: false, location: "dotclaude", contentMerged: false };
+      }
+      await fs7.writeFile(dotClaudePath, `${dotClaudeReference}
+`, "utf-8");
+      return { created: false, updated: true, location: "dotclaude", contentMerged: true };
+    }
+  }
+  await fs7.mkdir(path7.dirname(dotClaudePath), { recursive: true });
+  await fs7.writeFile(dotClaudePath, `${dotClaudeReference}
+`, "utf-8");
+  return { created: true, updated: false, location: "dotclaude", contentMerged: false };
+}
+
+// src/core/rules.ts
+import { createHash as createHash2 } from "crypto";
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseFrontmatter2(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match || !match[1]) {
+    return { frontmatter: null, body: content };
+  }
+  const rawYaml = match[1];
+  const body = content.slice(match[0].length);
+  try {
+    const frontmatter = parseSimpleYaml(rawYaml);
+    return { frontmatter, body };
+  } catch {
+    return { frontmatter: null, body: content };
+  }
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  let currentKey = null;
+  let currentValue = null;
+  let isArray = false;
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    if (line.match(/^\s+-\s+/)) {
+      if (currentKey && isArray) {
+        const value = line.replace(/^\s+-\s+/, "").replace(/^["']|["']$/g, "").trim();
+        currentValue.push(value);
+      }
+      continue;
+    }
+    if (line.startsWith("  ") && currentKey && typeof currentValue === "object" && !isArray) {
+      const nestedMatch = line.match(/^\s+(\w+):\s*["']?(.*)["']?$/);
+      if (nestedMatch?.[1] && nestedMatch[2] !== void 0) {
+        const key = nestedMatch[1];
+        const value = nestedMatch[2].replace(/^["']|["']$/g, "");
+        currentValue[key] = value;
+      }
+      continue;
+    }
+    if (currentKey && currentValue !== null) {
+      result[currentKey] = currentValue;
+      currentValue = null;
+      isArray = false;
+    }
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match?.[1] && match[2] !== void 0) {
+      const key = match[1];
+      const value = match[2].trim();
+      currentKey = key;
+      if (value === "") {
+        currentValue = {};
+        isArray = false;
+      } else if (value.startsWith("[") && value.endsWith("]")) {
+        try {
+          currentValue = JSON.parse(value);
+          result[key] = currentValue;
+          currentKey = null;
+          currentValue = null;
+        } catch {
+          result[key] = value.replace(/^["']|["']$/g, "");
+          currentKey = null;
+          currentValue = null;
+        }
+      } else {
+        result[key] = value.replace(/^["']|["']$/g, "");
+        currentKey = null;
+        currentValue = null;
+      }
+    }
+  }
+  if (currentKey && currentValue !== null) {
+    result[currentKey] = currentValue;
+  }
+  return result;
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = [];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - "${item}"`);
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${key}:`);
+      for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        const quotedValue = needsQuoting(String(nestedValue)) ? `"${String(nestedValue)}"` : String(nestedValue);
+        lines.push(`  ${nestedKey}: ${quotedValue}`);
+      }
+    } else {
+      const strValue = String(value);
+      const quotedValue = needsQuoting(strValue) ? `"${strValue}"` : strValue;
+      lines.push(`${key}: ${quotedValue}`);
+    }
+  }
+  return lines.join("\n");
+}
+function needsQuoting(value) {
+  return value.includes(":") || value.includes("#") || value.includes("@") || value === "true" || value === "false" || /^\d+$/.test(value);
+}
+function adjustHeadingLevels(content, increment) {
+  if (!content) return "";
+  let inCodeBlock = false;
+  return content.split("\n").map((line) => {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      return line;
+    }
+    if (inCodeBlock) {
+      return line;
+    }
+    const headingMatch = line.match(/^(#{1,6})(\s+.*)$/);
+    if (!headingMatch || !headingMatch[1]) {
+      return line;
+    }
+    const hashes = headingMatch[1];
+    const rest = headingMatch[2] || "";
+    const currentLevel = hashes.length;
+    const newLevel = Math.min(6, Math.max(1, currentLevel + increment));
+    return "#".repeat(newLevel) + rest;
+  }).join("\n");
+}
+function parseRule(content, relativePath) {
+  const { frontmatter, body } = parseFrontmatter2(content);
+  if (frontmatter) {
+    const pathsMatch = content.match(/^---\r?\n[\s\S]*?paths:\s*\n((?:\s+-\s+.+\n?)+)/m);
+    if (pathsMatch?.[1]) {
+      const pathsContent = pathsMatch[1];
+      const paths = pathsContent.split("\n").filter((line) => line.trim().startsWith("-")).map(
+        (line) => line.replace(/^\s+-\s+/, "").replace(/^["']|["']$/g, "").trim()
+      ).filter((p) => p.length > 0);
+      if (paths.length > 0) {
+        frontmatter.paths = paths;
+      }
+    }
+  }
+  return {
+    relativePath,
+    rawContent: content,
+    frontmatter,
+    body
+  };
+}
+function generatePathsComment(paths) {
+  if (!paths || paths.length === 0) return "";
+  if (paths.length === 1) {
+    return `<!-- Applies to: ${paths[0]} -->`;
+  }
+  return `<!-- Applies to:
+${paths.map((p) => `     - ${p}`).join("\n")}
+-->`;
+}
+function generateRulesSection(rules, markerPrefix) {
+  const sortedRules = [...rules].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  const contentParts = [];
+  contentParts.push("# Project Rules");
+  contentParts.push("");
+  for (const rule of sortedRules) {
+    contentParts.push(`<!-- Rule: ${rule.relativePath} -->`);
+    if (rule.frontmatter?.paths && rule.frontmatter.paths.length > 0) {
+      contentParts.push(generatePathsComment(rule.frontmatter.paths));
+    }
+    const adjustedBody = adjustHeadingLevels(rule.body.trim(), 1);
+    contentParts.push(adjustedBody);
+    contentParts.push("");
+  }
+  const contentForHash = contentParts.join("\n").trim();
+  const hash = createHash2("sha256").update(contentForHash).digest("hex");
+  const contentHash = `sha256:${hash.slice(0, 12)}`;
+  const parts = [];
+  parts.push(`<!-- ${markerPrefix}:rules:start -->`);
+  parts.push(`<!-- DO NOT EDIT THIS SECTION - Managed by agent-conf -->`);
+  parts.push(`<!-- Content hash: ${contentHash} -->`);
+  parts.push(`<!-- Rule count: ${rules.length} -->`);
+  parts.push("");
+  parts.push(contentForHash);
+  parts.push("");
+  parts.push(`<!-- ${markerPrefix}:rules:end -->`);
+  return parts.join("\n");
+}
+function updateAgentsMdWithRules(agentsMdContent, rulesSection, markerPrefix) {
+  const rulesStartMarker = `<!-- ${markerPrefix}:rules:start -->`;
+  const rulesEndMarker = `<!-- ${markerPrefix}:rules:end -->`;
+  const startIdx = agentsMdContent.indexOf(rulesStartMarker);
+  const endIdx = agentsMdContent.indexOf(rulesEndMarker);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = agentsMdContent.slice(0, startIdx);
+    const after = agentsMdContent.slice(endIdx + rulesEndMarker.length);
+    return before + rulesSection + after;
+  }
+  const globalEndMarker = `<!-- ${markerPrefix}:global:end -->`;
+  const repoStartMarker = `<!-- ${markerPrefix}:repo:start -->`;
+  const globalEndIdx = agentsMdContent.indexOf(globalEndMarker);
+  if (globalEndIdx !== -1) {
+    const insertPoint = globalEndIdx + globalEndMarker.length;
+    const before = agentsMdContent.slice(0, insertPoint);
+    const after = agentsMdContent.slice(insertPoint);
+    return `${before}
+
+${rulesSection}${after}`;
+  }
+  const repoStartIdx = agentsMdContent.indexOf(repoStartMarker);
+  if (repoStartIdx !== -1) {
+    const before = agentsMdContent.slice(0, repoStartIdx);
+    const after = agentsMdContent.slice(repoStartIdx);
+    return `${before}${rulesSection}
+
+${after}`;
+  }
+  return `${agentsMdContent.trimEnd()}
+
+${rulesSection}
+`;
+}
+function addRuleMetadata(rule, metadataPrefix) {
+  const managedKey = `${metadataPrefix}_managed`;
+  const hashKey = `${metadataPrefix}_content_hash`;
+  const sourceKey = `${metadataPrefix}_source_path`;
+  const hashMetadataPrefix = metadataPrefix.replace(/_/g, "-");
+  const contentHash = computeContentHash(rule.rawContent, {
+    metadataPrefix: hashMetadataPrefix
+  });
+  const existingFrontmatter = rule.frontmatter || {};
+  const existingMetadata = existingFrontmatter.metadata || {};
+  const newMetadata = {
+    ...existingMetadata,
+    [managedKey]: "true",
+    [hashKey]: contentHash,
+    [sourceKey]: rule.relativePath
+  };
+  const newFrontmatter = {};
+  for (const [key, value] of Object.entries(existingFrontmatter)) {
+    if (key !== "metadata") {
+      newFrontmatter[key] = value;
+    }
+  }
+  newFrontmatter.metadata = newMetadata;
+  const yamlContent = serializeFrontmatter(newFrontmatter);
+  return `---
+${yamlContent}
+---
+${rule.body}`;
+}
+
+// src/core/targets.ts
+var SUPPORTED_TARGETS = ["claude", "codex"];
+var TARGET_CONFIGS = {
+  claude: {
+    dir: ".claude",
+    instructionsFile: "CLAUDE.md"
+  },
+  codex: {
+    dir: ".codex",
+    instructionsFile: null
+    // Codex reads AGENTS.md directly
+  }
+};
+function isValidTarget(target) {
+  return SUPPORTED_TARGETS.includes(target);
+}
+function parseTargets(input) {
+  const targets = [];
+  for (const t of input) {
+    const parts = t.split(",").map((p) => p.trim().toLowerCase());
+    for (const part of parts) {
+      if (!isValidTarget(part)) {
+        throw new Error(
+          `Invalid target "${part}". Supported targets: ${SUPPORTED_TARGETS.join(", ")}`
+        );
+      }
+      if (!targets.includes(part)) {
+        targets.push(part);
+      }
+    }
+  }
+  return targets.length > 0 ? targets : ["claude"];
+}
+function getTargetConfig(target) {
+  return TARGET_CONFIGS[target];
+}
+
+// src/core/sync.ts
+async function discoverRules(rulesDir) {
+  try {
+    await fs8.access(rulesDir);
+  } catch {
+    return [];
+  }
+  const ruleFiles = await fg("**/*.md", {
+    cwd: rulesDir,
+    absolute: false
+  });
+  const rules = [];
+  for (const relativePath of ruleFiles) {
+    const fullPath = path8.join(rulesDir, relativePath);
+    const content = await fs8.readFile(fullPath, "utf-8");
+    rules.push(parseRule(content, relativePath));
+  }
+  return rules;
+}
+function computeRulesHash(rules) {
+  if (rules.length === 0) return "";
+  const sorted = [...rules].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  const combined = sorted.map((r) => `${r.relativePath}:${r.body}`).join("\n---\n");
+  const hash = createHash3("sha256").update(combined).digest("hex");
+  return hash.slice(0, 16);
+}
+async function syncRules(options) {
+  const { sourceRulesPath, targetDir, targets, markerPrefix, metadataPrefix, agentsMdContent } = options;
+  const rules = await discoverRules(sourceRulesPath);
+  const result = {
+    rules,
+    updatedAgentsMd: null,
+    claudeFiles: [],
+    modifiedRules: [],
+    contentHash: ""
+  };
+  if (rules.length === 0) {
+    return result;
+  }
+  result.contentHash = computeRulesHash(rules);
+  if (targets.includes("claude")) {
+    const claudeRulesDir = path8.join(targetDir, ".claude", "rules");
+    for (const rule of rules) {
+      const targetPath = path8.join(claudeRulesDir, rule.relativePath);
+      await fs8.mkdir(path8.dirname(targetPath), { recursive: true });
+      const contentWithMetadata = addRuleMetadata(rule, metadataPrefix);
+      let existingContent = null;
+      try {
+        existingContent = await fs8.readFile(targetPath, "utf-8");
+      } catch {
+      }
+      if (existingContent !== contentWithMetadata) {
+        await fs8.writeFile(targetPath, contentWithMetadata, "utf-8");
+        result.modifiedRules.push(rule.relativePath);
+      }
+      result.claudeFiles.push(rule.relativePath);
+    }
+  }
+  if (targets.includes("codex")) {
+    const rulesSection = generateRulesSection(rules, markerPrefix);
+    result.updatedAgentsMd = updateAgentsMdWithRules(agentsMdContent, rulesSection, markerPrefix);
+  }
+  return result;
+}
+async function sync(targetDir, resolvedSource, options = { override: false, targets: ["claude"] }) {
+  const markerPrefix = resolvedSource.markerPrefix;
+  const globalContent = await fs8.readFile(resolvedSource.agentsMdPath, "utf-8");
+  const mergeResult = await mergeAgentsMd(targetDir, globalContent, resolvedSource.source, {
+    override: options.override,
+    markerPrefix
+  });
+  await writeAgentsMd(targetDir, mergeResult.content);
+  const skillDirs = await fg("*/", {
+    cwd: resolvedSource.skillsPath,
+    onlyDirectories: true,
+    deep: 1
+  });
+  const skillNames = skillDirs.map((d) => d.replace(/\/$/, ""));
+  const validationErrors = [];
+  for (const skillName of skillNames) {
+    const skillMdPath = path8.join(resolvedSource.skillsPath, skillName, "SKILL.md");
+    try {
+      const content = await fs8.readFile(skillMdPath, "utf-8");
+      const error = validateSkillFrontmatter(content, skillName, skillMdPath);
+      if (error) {
+        validationErrors.push(error);
+      }
+    } catch {
+    }
+  }
+  const targetResults = [];
+  let totalCopied = 0;
+  const allModifiedSkills = /* @__PURE__ */ new Set();
+  for (const target of options.targets) {
+    const config = getTargetConfig(target);
+    const skillsResult = await syncSkillsToTarget(
+      targetDir,
+      resolvedSource.skillsPath,
+      skillNames,
+      config,
+      markerPrefix
+    );
+    totalCopied += skillsResult.copied;
+    for (const skill of skillsResult.modifiedSkills) {
+      allModifiedSkills.add(skill);
+    }
+    let instructionsResult;
+    if (config.instructionsFile) {
+      instructionsResult = await ensureInstructionsMd(
+        targetDir,
+        config,
+        target === "claude" ? mergeResult.claudeMdLocation : null
+      );
+    } else {
+      instructionsResult = {
+        created: false,
+        updated: false,
+        location: null,
+        contentMerged: false
+      };
+    }
+    targetResults.push({
+      target,
+      instructionsMd: instructionsResult,
+      skills: { copied: skillsResult.copied }
+    });
+  }
+  let rulesResult = null;
+  if (resolvedSource.rulesPath) {
+    const currentAgentsMd = await fs8.readFile(path8.join(targetDir, "AGENTS.md"), "utf-8");
+    rulesResult = await syncRules({
+      sourceRulesPath: resolvedSource.rulesPath,
+      targetDir,
+      targets: options.targets,
+      markerPrefix,
+      metadataPrefix: markerPrefix.replace(/-/g, "_"),
+      agentsMdContent: currentAgentsMd
+    });
+    if (rulesResult.updatedAgentsMd && options.targets.includes("codex")) {
+      await writeAgentsMd(targetDir, rulesResult.updatedAgentsMd);
+    }
+  }
+  const lockfileOptions = {
+    source: resolvedSource.source,
+    globalBlockContent: globalContent,
+    skills: skillNames,
+    targets: options.targets,
+    markerPrefix
+  };
+  if (options.pinnedVersion) {
+    lockfileOptions.pinnedVersion = options.pinnedVersion;
+  }
+  if (rulesResult && rulesResult.rules.length > 0) {
+    lockfileOptions.rules = {
+      files: rulesResult.rules.map((r) => r.relativePath),
+      content_hash: rulesResult.contentHash
+    };
+  }
+  const lockfile = await writeLockfile(targetDir, lockfileOptions);
+  const result = {
+    lockfile,
+    agentsMd: {
+      merged: mergeResult.merged,
+      preservedRepoContent: mergeResult.preservedRepoContent
+    },
+    targets: targetResults,
+    skills: {
+      synced: skillNames,
+      modified: [...allModifiedSkills],
+      totalCopied,
+      validationErrors
+    }
+  };
+  if (rulesResult && rulesResult.rules.length > 0) {
+    result.rules = {
+      synced: rulesResult.rules.map((r) => r.relativePath),
+      modified: rulesResult.modifiedRules,
+      contentHash: rulesResult.contentHash,
+      claudeFiles: rulesResult.claudeFiles,
+      codexUpdated: rulesResult.updatedAgentsMd !== null
+    };
+  }
+  return result;
+}
+async function syncSkillsToTarget(targetDir, sourceSkillsPath, skillNames, config, metadataPrefix) {
+  const targetSkillsPath = path8.join(targetDir, config.dir, "skills");
+  let copied = 0;
+  const modifiedSkills = [];
+  for (const skillName of skillNames) {
+    const sourceDir = path8.join(sourceSkillsPath, skillName);
+    const targetSkillDir = path8.join(targetSkillsPath, skillName);
+    const result = await copySkillDirectory(sourceDir, targetSkillDir, metadataPrefix);
+    copied += result.copied;
+    if (result.modified) {
+      modifiedSkills.push(skillName);
+    }
+  }
+  return { copied, modifiedSkills };
+}
+async function copySkillDirectory(sourceDir, targetDir, metadataPrefix) {
+  await fs8.mkdir(targetDir, { recursive: true });
+  const entries = await fs8.readdir(sourceDir, { withFileTypes: true });
+  let copied = 0;
+  let modified = false;
+  for (const entry of entries) {
+    const sourcePath = path8.join(sourceDir, entry.name);
+    const targetPath = path8.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      const subResult = await copySkillDirectory(sourcePath, targetPath, metadataPrefix);
+      copied += subResult.copied;
+      if (subResult.modified) modified = true;
+    } else if (entry.name === "SKILL.md") {
+      const content = await fs8.readFile(sourcePath, "utf-8");
+      const contentWithMetadata = addManagedMetadata(content, { metadataPrefix });
+      let existingContent = null;
+      try {
+        existingContent = await fs8.readFile(targetPath, "utf-8");
+      } catch {
+      }
+      if (existingContent !== contentWithMetadata) {
+        await fs8.writeFile(targetPath, contentWithMetadata, "utf-8");
+        modified = true;
+      }
+      copied++;
+    } else {
+      let needsCopy = true;
+      try {
+        const [sourceContent, targetContent] = await Promise.all([
+          fs8.readFile(sourcePath),
+          fs8.readFile(targetPath)
+        ]);
+        needsCopy = !sourceContent.equals(targetContent);
+      } catch {
+      }
+      if (needsCopy) {
+        await fs8.copyFile(sourcePath, targetPath);
+        modified = true;
+      }
+      copied++;
+    }
+  }
+  return { copied, modified };
+}
+async function ensureInstructionsMd(targetDir, config, existingLocation) {
+  if (!config.instructionsFile) {
+    return { created: false, updated: false, location: null, contentMerged: false };
+  }
+  const result = await ensureClaudeMd(targetDir, existingLocation);
+  return {
+    created: result.created,
+    updated: result.updated,
+    location: result.location === "dotclaude" ? "dotdir" : result.location,
+    contentMerged: result.contentMerged
+  };
+}
+async function getSyncStatus(targetDir) {
+  const result = await readLockfile(targetDir);
+  const agentsMdPath = path8.join(targetDir, "AGENTS.md");
+  const skillsPath = path8.join(targetDir, ".claude", "skills");
+  const [agentsMdExists, skillsExist] = await Promise.all([
+    fs8.access(agentsMdPath).then(() => true).catch(() => false),
+    fs8.access(skillsPath).then(() => true).catch(() => false)
+  ]);
+  return {
+    hasSynced: result !== null,
+    lockfile: result?.lockfile ?? null,
+    agentsMdExists,
+    skillsExist,
+    schemaWarning: result?.schemaCompatibility.warning ?? null,
+    schemaError: result?.schemaCompatibility.error ?? null
+  };
+}
+function findOrphanedSkills(previousSkills, currentSkills) {
+  return previousSkills.filter((skill) => !currentSkills.includes(skill));
+}
+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) {
+      const skillDir = path8.join(targetDir, `.${target}`, "skills", skillName);
+      try {
+        await fs8.access(skillDir);
+      } catch {
+        continue;
+      }
+      const skillMdPath = path8.join(skillDir, "SKILL.md");
+      try {
+        const content = await fs8.readFile(skillMdPath, "utf-8");
+        const { isManaged, hasManualChanges } = await import("./skill-metadata-XXNMIXLD.js");
+        if (!isManaged(content, metadataOptions)) {
+          if (!skipped.includes(skillName)) {
+            skipped.push(skillName);
+          }
+          continue;
+        }
+        const wasInPreviousLockfile = previouslyTrackedSkills.includes(skillName);
+        const isUnmodified = !hasManualChanges(content, metadataOptions);
+        if (!wasInPreviousLockfile && !isUnmodified) {
+          if (!skipped.includes(skillName)) {
+            skipped.push(skillName);
+          }
+          continue;
+        }
+      } catch {
+        if (!skipped.includes(skillName)) {
+          skipped.push(skillName);
+        }
+        continue;
+      }
+      await fs8.rm(skillDir, { recursive: true, force: true });
+      wasDeleted = true;
+    }
+    if (wasDeleted && !deleted.includes(skillName)) {
+      deleted.push(skillName);
+    }
+  }
+  return { deleted, skipped };
+}
+
+// src/commands/shared.ts
+import * as fs13 from "fs/promises";
+import * as path13 from "path";
+import * as prompts4 from "@clack/prompts";
+import pc6 from "picocolors";
+
+// src/core/hooks.ts
+import * as fs9 from "fs/promises";
+import * as path9 from "path";
+var DEFAULT_CLI_NAME = "agent-conf";
+var DEFAULT_CONFIG_DIR = ".agent-conf";
+var DEFAULT_LOCKFILE_NAME = "lockfile.json";
+var HOOK_IDENTIFIER = "# agent-conf pre-commit hook";
+function generatePreCommitHook(config) {
+  const { cliName, configDir, lockfileName } = config;
+  return `#!/bin/bash
+# ${cliName} pre-commit hook
+# Prevents committing changes to managed files (skills and AGENTS.md global block)
+#
+# Installation:
+#   Copy this file to .git/hooks/pre-commit
+#   Or run: ${cliName} hooks install
+
+set -e
+
+# Get the repository root
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+# Check if ${cliName} has been synced
+if [ ! -f "$REPO_ROOT/${configDir}/${lockfileName}" ]; then
+    # Not synced, nothing to check
+    exit 0
+fi
+
+# Check if ${cliName} CLI is available
+if ! command -v ${cliName} &> /dev/null; then
+    # CLI not installed, skip check
+    exit 0
+fi
+
+# Run ${cliName} check and capture output
+cd "$REPO_ROOT"
+CHECK_OUTPUT=$(${cliName} check 2>&1) || CHECK_EXIT=$?
+CHECK_EXIT=\${CHECK_EXIT:-0}
+
+if [ $CHECK_EXIT -ne 0 ]; then
+    echo ""
+    echo "Error: Cannot commit changes to ${cliName}-managed files"
+    echo ""
+    echo "Output from '${cliName} check' command:"
+    echo "$CHECK_OUTPUT"
+    echo ""
+    echo "Options:"
+    echo "  1. Discard your changes: git checkout -- <file>"
+    echo "  2. Skip this check: git commit --no-verify"
+    echo "  3. Restore managed files: ${cliName} sync"
+    echo "  4. For AGENTS.md: edit only the repo-specific block (between repo:start and repo:end)"
+    echo "  5. For skills: create a new custom skill instead"
+    echo ""
+    exit 1
+fi
+
+exit 0
+`;
+}
+function getHookConfig(config) {
+  return {
+    cliName: config?.cliName ?? DEFAULT_CLI_NAME,
+    configDir: config?.configDir ?? DEFAULT_CONFIG_DIR,
+    lockfileName: config?.lockfileName ?? DEFAULT_LOCKFILE_NAME
+  };
+}
+async function installPreCommitHook(targetDir, config) {
+  const hookConfig = getHookConfig(config);
+  const hooksDir = path9.join(targetDir, ".git", "hooks");
+  const hookPath = path9.join(hooksDir, "pre-commit");
+  const hookContent = generatePreCommitHook(hookConfig);
+  await fs9.mkdir(hooksDir, { recursive: true });
+  let existingContent = null;
+  try {
+    existingContent = await fs9.readFile(hookPath, "utf-8");
+  } catch {
+  }
+  if (existingContent !== null) {
+    const isOurHook = existingContent.includes(HOOK_IDENTIFIER);
+    if (!isOurHook) {
+      return {
+        installed: false,
+        path: hookPath,
+        alreadyExisted: true,
+        wasUpdated: false
+      };
+    }
+    if (existingContent === hookContent) {
+      return {
+        installed: true,
+        path: hookPath,
+        alreadyExisted: true,
+        wasUpdated: false
+      };
+    }
+    await fs9.writeFile(hookPath, hookContent, { mode: 493 });
+    return {
+      installed: true,
+      path: hookPath,
+      alreadyExisted: true,
+      wasUpdated: true
+    };
+  }
+  await fs9.writeFile(hookPath, hookContent, { mode: 493 });
+  return {
+    installed: true,
+    path: hookPath,
+    alreadyExisted: false,
+    wasUpdated: false
+  };
+}
+
+// src/core/source.ts
+import { exec } from "child_process";
+import * as fs11 from "fs/promises";
+import * as path11 from "path";
+import { promisify } from "util";
+import { simpleGit as simpleGit2 } from "simple-git";
+
+// src/config/loader.ts
+import * as fs10 from "fs/promises";
+import * as path10 from "path";
+import { parse as parseYaml } from "yaml";
+var CANONICAL_REPO_CONFIG = "agent-conf.yaml";
+async function loadCanonicalRepoConfig(basePath) {
+  const configPath = path10.join(basePath, CANONICAL_REPO_CONFIG);
+  try {
+    const content = await fs10.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 = path11.resolve(options.path);
+  } else {
+    basePath = await findCanonicalRepo(process.cwd());
+  }
+  await validateCanonicalRepo(basePath);
+  const git = simpleGit2(basePath);
+  let commitSha;
+  try {
+    const log2 = await git.log({ maxCount: 1 });
+    commitSha = log2.latest?.hash;
+  } catch {
+  }
+  const canonicalConfig = await loadCanonicalRepoConfig(basePath);
+  const markerPrefix = canonicalConfig?.markers.prefix ?? "agent-conf";
+  const rulesDir = canonicalConfig?.content.rules_dir;
+  const source = {
+    type: "local",
+    path: basePath,
+    commit_sha: commitSha
+  };
+  return {
+    source,
+    basePath,
+    agentsMdPath: path11.join(basePath, "instructions", "AGENTS.md"),
+    skillsPath: path11.join(basePath, "skills"),
+    rulesPath: rulesDir ? path11.join(basePath, rulesDir) : null,
+    markerPrefix
+  };
+}
+async function resolveGithubSource(options, tempDir) {
+  const { repository, ref = DEFAULT_REF } = options;
+  await cloneRepository(repository, ref, tempDir);
+  const clonedGit = simpleGit2(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 rulesDir = canonicalConfig?.content.rules_dir;
+  const source = {
+    type: "github",
+    repository,
+    commit_sha: commitSha,
+    ref
+  };
+  return {
+    source,
+    basePath: tempDir,
+    agentsMdPath: path11.join(tempDir, "instructions", "AGENTS.md"),
+    skillsPath: path11.join(tempDir, "skills"),
+    rulesPath: rulesDir ? path11.join(tempDir, rulesDir) : null,
+    markerPrefix
+  };
+}
+async function cloneRepository(repository, ref, tempDir) {
+  if (await isGhAvailable()) {
+    try {
+      await execAsync(`gh repo clone ${repository} ${tempDir} -- --depth 1 --branch ${ref}`);
+      return;
+    } catch {
+    }
+  }
+  const token = process.env.GITHUB_TOKEN;
+  const repoUrl = token ? `https://x-access-token:${token}@github.com/${repository}.git` : `https://github.com/${repository}.git`;
+  const git = simpleGit2();
+  await git.clone(repoUrl, tempDir, ["--depth", "1", "--branch", ref]);
+}
+async function isGhAvailable() {
+  try {
+    await execAsync("gh --version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findCanonicalRepo(startDir) {
+  let currentDir = path11.resolve(startDir);
+  const root = path11.parse(currentDir).root;
+  let checkDir = currentDir;
+  while (checkDir !== root) {
+    if (await isCanonicalRepo(checkDir)) {
+      return checkDir;
+    }
+    checkDir = path11.dirname(checkDir);
+  }
+  currentDir = path11.resolve(startDir);
+  while (currentDir !== root) {
+    const parentDir = path11.dirname(currentDir);
+    const siblingCanonicalRepo = path11.join(parentDir, "agent-conf");
+    if (await isCanonicalRepo(siblingCanonicalRepo)) {
+      return siblingCanonicalRepo;
+    }
+    currentDir = parentDir;
+  }
+  throw new Error(
+    "Could not find canonical repository. Please specify --local <path> or run from within the canonical repo."
+  );
+}
+async function isCanonicalRepo(dir) {
+  try {
+    const stat4 = await fs11.stat(dir).catch(() => null);
+    if (!stat4?.isDirectory()) {
+      return false;
+    }
+    const instructionsPath = path11.join(dir, "instructions", "AGENTS.md");
+    const skillsPath = path11.join(dir, "skills");
+    const [instructionsExists, skillsExists] = await Promise.all([
+      fs11.access(instructionsPath).then(() => true).catch(() => false),
+      fs11.access(skillsPath).then(() => true).catch(() => false)
+    ]);
+    if (!instructionsExists || !skillsExists) {
+      return false;
+    }
+    try {
+      const git = simpleGit2(dir);
+      const remotes = await git.getRemotes(true);
+      const hasMatchingRemote = remotes.some(
+        (r) => r.refs.fetch?.includes("agent-conf") || r.refs.push?.includes("agent-conf")
+      );
+      if (hasMatchingRemote) {
+        return true;
+      }
+    } catch {
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function validateCanonicalRepo(basePath) {
+  const agentsMdPath = path11.join(basePath, "instructions", "AGENTS.md");
+  const skillsPath = path11.join(basePath, "skills");
+  const [agentsMdExists, skillsExists] = await Promise.all([
+    fs11.access(agentsMdPath).then(() => true).catch(() => false),
+    fs11.access(skillsPath).then(() => true).catch(() => false)
+  ]);
+  if (!agentsMdExists) {
+    throw new Error(`Invalid canonical repository: missing instructions/AGENTS.md at ${basePath}`);
+  }
+  if (!skillsExists) {
+    throw new Error(`Invalid canonical repository: missing skills/ directory at ${basePath}`);
+  }
+}
+function formatSourceString(source) {
+  if (source.type === "github") {
+    const sha = source.commit_sha.slice(0, 7);
+    return `github:${source.repository}@${sha}`;
+  }
+  if (source.commit_sha) {
+    return `local:${source.path}@${source.commit_sha.slice(0, 7)}`;
+  }
+  return `local:${source.path}`;
+}
+
+// src/core/version.ts
+import { execSync } from "child_process";
+var GITHUB_API_BASE = "https://api.github.com";
+function getGitHubToken() {
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN;
+  }
+  try {
+    const token = execSync("gh auth token", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (token) {
+      return token;
+    }
+  } catch {
+  }
+  throw new Error(
+    `GitHub authentication required to access agent-conf releases.
+
+To fix this, do one of the following:
+
+1. Install and authenticate GitHub CLI (recommended):
+   brew install gh
+   gh auth login
+
+2. Set GITHUB_TOKEN environment variable:
+   export GITHUB_TOKEN=<your-personal-access-token>
+
+   Create a token at https://github.com/settings/tokens
+   with 'repo' scope for private repository access.`
+  );
+}
+function getGitHubHeaders() {
+  const token = getGitHubToken();
+  return {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "agent-conf-cli",
+    Authorization: `token ${token}`
+  };
+}
+async function getLatestRelease(repo) {
+  const url = `${GITHUB_API_BASE}/repos/${repo}/releases/latest`;
+  const response = await fetch(url, {
+    headers: getGitHubHeaders()
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error("No releases found for agent-conf repository");
+    }
+    throw new Error(`Failed to fetch latest release: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return parseReleaseResponse(data);
+}
+function parseReleaseResponse(data) {
+  const tag = data.tag_name;
+  return {
+    tag,
+    version: parseVersion(tag),
+    commitSha: data.target_commitish || "",
+    publishedAt: data.published_at,
+    tarballUrl: data.tarball_url
+  };
+}
+function parseVersion(tag) {
+  return tag.startsWith("v") ? tag.slice(1) : tag;
+}
+function formatTag(version) {
+  return version.startsWith("v") ? version : `v${version}`;
+}
+function isVersionRef(ref) {
+  const normalized = ref.startsWith("v") ? ref.slice(1) : ref;
+  return /^\d+\.\d+\.\d+(-[\w.]+)?$/.test(normalized);
+}
+function compareVersions(a, b) {
+  const parseVer = (v) => {
+    const clean = v.startsWith("v") ? v.slice(1) : v;
+    const [main, prerelease] = clean.split("-");
+    const parts = (main ?? "").split(".").map(Number);
+    return { parts, prerelease };
+  };
+  const verA = parseVer(a);
+  const verB = parseVer(b);
+  for (let i = 0; i < 3; i++) {
+    const partA = verA.parts[i] || 0;
+    const partB = verB.parts[i] || 0;
+    if (partA < partB) return -1;
+    if (partA > partB) return 1;
+  }
+  if (verA.prerelease && !verB.prerelease) return -1;
+  if (!verA.prerelease && verB.prerelease) return 1;
+  if (verA.prerelease && verB.prerelease) {
+    return verA.prerelease.localeCompare(verB.prerelease);
+  }
+  return 0;
+}
+
+// src/core/workflows.ts
+import * as fs12 from "fs/promises";
+import * as path12 from "path";
+var DEFAULT_CLI_NAME2 = "agent-conf";
+var WORKFLOWS_DIR = ".github/workflows";
+function getWorkflowConfig(sourceRepo, config) {
+  const name = config?.name ?? DEFAULT_CLI_NAME2;
+  const secretName = `${name.toUpperCase().replace(/-/g, "_")}_TOKEN`;
+  return {
+    sourceRepo,
+    cliName: config?.cliName ?? DEFAULT_CLI_NAME2,
+    secretName,
+    workflowPrefix: name
+  };
+}
+function getWorkflowFiles(config) {
+  const prefix = config.workflowPrefix;
+  return [
+    {
+      name: "sync",
+      filename: `${prefix}-sync.yml`,
+      reusableWorkflow: "sync-reusable.yml"
+    },
+    {
+      name: "check",
+      filename: `${prefix}-check.yml`,
+      reusableWorkflow: "check-reusable.yml"
+    }
+  ];
+}
+function getWorkflowsDir(repoRoot) {
+  return path12.join(repoRoot, WORKFLOWS_DIR);
+}
+function getWorkflowPath(repoRoot, filename) {
+  return path12.join(repoRoot, WORKFLOWS_DIR, filename);
+}
+function generateSyncWorkflow2(versionRef, config) {
+  const { sourceRepo, cliName, secretName } = config;
+  return `# ${cliName} Auto-Sync Workflow
+# Managed by ${cliName} CLI - do not edit the version ref manually
+#
+# This workflow syncs standards from the central repository.
+# Version changes should be made using: ${cliName} sync --ref <version>
+#
+# TOKEN: Requires a PAT with read access to the source repository.
+# Create a fine-grained PAT at https://github.com/settings/tokens?type=beta
+# with read access to ${sourceRepo}, then add it as ${secretName} secret.
+
+name: ${cliName} Sync
+
+on:
+  schedule:
+    - cron: '0 6 * * *'  # Daily at 6am UTC
+
+  workflow_dispatch:
+    inputs:
+      force:
+        description: 'Force sync even if no updates detected'
+        required: false
+        default: false
+        type: boolean
+
+  repository_dispatch:
+    types: [${cliName.replace(/-/g, "_")}-release]
+
+concurrency:
+  group: ${cliName}-sync
+  cancel-in-progress: false
+
+jobs:
+  sync:
+    uses: ${sourceRepo}/.github/workflows/sync-reusable.yml@${versionRef}
+    with:
+      force: \${{ inputs.force || false }}
+      reviewers: \${{ vars.${secretName.replace(/_TOKEN$/, "_REVIEWERS")} || '' }}
+    secrets:
+      token: \${{ secrets.${secretName} }}
+`;
+}
+function generateCheckWorkflow2(versionRef, config) {
+  const { sourceRepo, cliName } = config;
+  return `# ${cliName} File Integrity Check
+# Managed by ${cliName} CLI - do not edit the version ref manually
+#
+# This workflow checks that ${cliName}-managed files haven't been modified.
+# Version changes should be made using: ${cliName} sync --ref <version>
+
+name: ${cliName} Check
+
+on:
+  pull_request:
+    paths:
+      - '.claude/skills/**'
+      - '.codex/skills/**'
+      - 'AGENTS.md'
+  push:
+    paths:
+      - '.claude/skills/**'
+      - '.codex/skills/**'
+      - 'AGENTS.md'
+
+jobs:
+  check:
+    uses: ${sourceRepo}/.github/workflows/check-reusable.yml@${versionRef}
+`;
+}
+function generateWorkflow(workflow, versionRef, config) {
+  switch (workflow.name) {
+    case "sync":
+      return generateSyncWorkflow2(versionRef, config);
+    case "check":
+      return generateCheckWorkflow2(versionRef, config);
+    default:
+      throw new Error(`Unknown workflow: ${workflow.name}`);
+  }
+}
+async function ensureWorkflowsDir(repoRoot) {
+  const dir = getWorkflowsDir(repoRoot);
+  await fs12.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 fs12.writeFile(filePath, content, "utf-8");
+}
+async function syncWorkflows(repoRoot, versionRef, sourceRepo, resolvedConfig) {
+  const config = getWorkflowConfig(sourceRepo, resolvedConfig);
+  const workflowFiles = getWorkflowFiles(config);
+  const result = {
+    created: [],
+    updated: [],
+    unchanged: []
+  };
+  for (const workflow of workflowFiles) {
+    const filePath = getWorkflowPath(repoRoot, workflow.filename);
+    const expectedContent = generateWorkflow(workflow, versionRef, config);
+    let existingContent = null;
+    try {
+      existingContent = await fs12.readFile(filePath, "utf-8");
+    } catch {
+    }
+    if (existingContent === null) {
+      await writeWorkflow(repoRoot, workflow, versionRef, config);
+      result.created.push(workflow.filename);
+    } else if (existingContent !== expectedContent) {
+      await writeWorkflow(repoRoot, workflow, versionRef, config);
+      result.updated.push(workflow.filename);
+    } else {
+      result.unchanged.push(workflow.filename);
+    }
+  }
+  return result;
+}
+
+// src/commands/shared.ts
+async function parseAndValidateTargets(targetOptions) {
+  const logger = createLogger();
+  try {
+    return parseTargets(targetOptions ?? ["claude"]);
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    logger.info(`Supported targets: ${SUPPORTED_TARGETS.join(", ")}`);
+    process.exit(1);
+  }
+}
+async function resolveTargetDirectory() {
+  const logger = createLogger();
+  const cwd = process.cwd();
+  const gitRoot = await getGitRoot(cwd);
+  if (!gitRoot) {
+    logger.error(
+      "Not inside a git repository. Please run this command from within a git repository."
+    );
+    process.exit(1);
+  }
+  if (gitRoot !== cwd) {
+    logger.info(`Syncing to repository root: ${formatPath(gitRoot)}`);
+  }
+  return gitRoot;
+}
+async function resolveVersion(options, status, _commandName, repo) {
+  const logger = createLogger();
+  if (options.local !== void 0) {
+    return {
+      ref: "local",
+      version: void 0,
+      isRelease: false,
+      releaseInfo: null
+    };
+  }
+  if (options.ref) {
+    if (isVersionRef(options.ref)) {
+      return {
+        ref: formatTag(options.ref),
+        version: parseVersion(options.ref),
+        isRelease: true,
+        releaseInfo: null
+      };
+    }
+    return {
+      ref: options.ref,
+      version: void 0,
+      isRelease: false,
+      releaseInfo: null
+    };
+  }
+  if (options.pinned) {
+    if (!status.lockfile?.pinned_version) {
+      logger.error("Cannot use --pinned: no version pinned in lockfile.");
+      process.exit(1);
+    }
+    const version = status.lockfile.pinned_version;
+    return {
+      ref: formatTag(version),
+      version,
+      isRelease: true,
+      releaseInfo: null
+    };
+  }
+  if (!repo) {
+    logger.warn("No source repository specified. Using master branch.");
+    return {
+      ref: "master",
+      version: void 0,
+      isRelease: false,
+      releaseInfo: null
+    };
+  }
+  const spinner = logger.spinner("Fetching latest release...");
+  spinner.start();
+  try {
+    const release = await getLatestRelease(repo);
+    spinner.succeed(`Latest release: ${release.tag}`);
+    return {
+      ref: release.tag,
+      version: release.version,
+      isRelease: true,
+      releaseInfo: release
+    };
+  } catch {
+    spinner.info("No releases found, using master branch");
+    return {
+      ref: "master",
+      version: void 0,
+      isRelease: false,
+      releaseInfo: null
+    };
+  }
+}
+async function resolveSource(options, resolvedVersion) {
+  const logger = createLogger();
+  let resolvedSource;
+  let tempDir = null;
+  const spinner = logger.spinner("Resolving source...");
+  try {
+    if (options.local !== void 0) {
+      spinner.start();
+      const localSourceOptions = typeof options.local === "string" ? { path: resolvePath(options.local) } : {};
+      resolvedSource = await resolveLocalSource(localSourceOptions);
+      spinner.succeed(`Using local source: ${formatPath(resolvedSource.basePath)}`);
+      return { resolvedSource, tempDir, repository: "" };
+    }
+    const repository = options.source;
+    if (!repository) {
+      spinner.fail("No canonical source specified");
+      logger.error(`No canonical source specified.
+
+Specify a source using one of these methods:
+  1. CLI flag: agent-conf init --source acme/engineering-standards
+  2. Config file: Add 'source.repository' to .agent-conf.yaml
+
+Example .agent-conf.yaml:
+  source:
+    type: github
+    repository: acme/engineering-standards`);
+      process.exit(1);
+    }
+    spinner.start();
+    tempDir = await createTempDir();
+    const ref = resolvedVersion.ref;
+    spinner.text = `Cloning ${repository}@${ref}...`;
+    resolvedSource = await resolveGithubSource({ repository, ref }, tempDir);
+    spinner.succeed(`Cloned from GitHub: ${formatSourceString(resolvedSource.source)}`);
+    return { resolvedSource, tempDir, repository };
+  } catch (error) {
+    spinner.fail("Failed to resolve source");
+    logger.error(error instanceof Error ? error.message : String(error));
+    if (tempDir) await removeTempDir(tempDir);
+    process.exit(1);
+  }
+}
+async function promptMergeOrOverride(status, options, tempDir) {
+  let shouldOverride = options.override ?? false;
+  if (status.hasSynced) {
+    return shouldOverride;
+  }
+  if (status.agentsMdExists && !options.yes && !options.override) {
+    const action = await prompts4.select({
+      message: "An AGENTS.md file already exists. How would you like to proceed?",
+      options: [
+        {
+          value: "merge",
+          label: "Merge (recommended)",
+          hint: "Preserves your existing content in a repository-specific block"
+        },
+        {
+          value: "override",
+          label: "Override",
+          hint: "Replaces everything with fresh global standards"
+        }
+      ]
+    });
+    if (prompts4.isCancel(action)) {
+      prompts4.cancel("Operation cancelled");
+      if (tempDir) await removeTempDir(tempDir);
+      process.exit(0);
+    }
+    shouldOverride = action === "override";
+  }
+  return shouldOverride;
+}
+async function checkModifiedFilesBeforeSync(targetDir, targets, options, tempDir) {
+  const modifiedFiles = await getModifiedManagedFiles(targetDir, targets);
+  if (modifiedFiles.length === 0) {
+    return true;
+  }
+  const logger = createLogger();
+  console.log();
+  console.log(pc6.yellow(`\u26A0 ${modifiedFiles.length} managed file(s) have been manually modified:`));
+  for (const file of modifiedFiles) {
+    const label = file.type === "agents" ? "(global block)" : "";
+    console.log(`  ${pc6.yellow("~")} ${file.path} ${pc6.dim(label)}`);
+  }
+  console.log();
+  if (options.yes) {
+    logger.warn("Proceeding with sync (--yes flag). Modified files will be overwritten.");
+    return true;
+  }
+  const proceed = await prompts4.confirm({
+    message: "These files will be overwritten. Continue with sync?",
+    initialValue: false
+  });
+  if (prompts4.isCancel(proceed) || !proceed) {
+    prompts4.cancel("Sync cancelled. Your modified files were preserved.");
+    if (tempDir) await removeTempDir(tempDir);
+    process.exit(0);
+  }
+  return true;
+}
+async function performSync(options) {
+  const { targetDir, resolvedSource, resolvedVersion, shouldOverride, targets, context, tempDir } = options;
+  const logger = createLogger();
+  const previousLockfileResult = await readLockfile(targetDir);
+  const previousSkills = previousLockfileResult?.lockfile.content.skills ?? [];
+  const previousRules = previousLockfileResult?.lockfile.content.rules?.files ?? [];
+  const previousTargets = previousLockfileResult?.lockfile.content.targets ?? ["claude"];
+  const syncSpinner = logger.spinner("Syncing...");
+  syncSpinner.start();
+  try {
+    const syncOptions = {
+      override: shouldOverride,
+      targets
+    };
+    if (resolvedVersion.version) {
+      syncOptions.pinnedVersion = resolvedVersion.version;
+    }
+    const result = await sync(targetDir, resolvedSource, syncOptions);
+    syncSpinner.stop();
+    const orphanedSkills = findOrphanedSkills(previousSkills, result.skills.synced);
+    let orphanResult = { deleted: [], skipped: [] };
+    if (orphanedSkills.length > 0) {
+      const allTargets = [.../* @__PURE__ */ new Set([...previousTargets, ...targets])];
+      if (options.yes) {
+        orphanResult = await deleteOrphanedSkills(
+          targetDir,
+          orphanedSkills,
+          allTargets,
+          previousSkills
+        );
+      } else {
+        console.log();
+        console.log(
+          pc6.yellow(
+            `\u26A0 ${orphanedSkills.length} skill(s) were previously synced but are no longer in the source:`
+          )
+        );
+        for (const skill of orphanedSkills) {
+          console.log(`  ${pc6.yellow("\xB7")} ${skill}`);
+        }
+        console.log();
+        const deleteOrphans = await prompts4.confirm({
+          message: "Delete these orphaned skills?",
+          initialValue: true
+        });
+        if (prompts4.isCancel(deleteOrphans)) {
+          logger.info("Skipping orphan deletion.");
+        } else if (deleteOrphans) {
+          orphanResult = await deleteOrphanedSkills(
+            targetDir,
+            orphanedSkills,
+            allTargets,
+            previousSkills
+          );
+        }
+      }
+    }
+    if (result.skills.validationErrors.length > 0) {
+      console.log();
+      console.log(
+        pc6.yellow(`\u26A0 ${result.skills.validationErrors.length} skill(s) have invalid frontmatter:`)
+      );
+      for (const error of result.skills.validationErrors) {
+        console.log(`  ${pc6.yellow("!")} ${error.skillName}/SKILL.md`);
+        for (const msg of error.errors) {
+          console.log(`      ${pc6.dim("-")} ${msg}`);
+        }
+      }
+      console.log();
+      console.log(pc6.dim("Skills must have frontmatter with 'name' and 'description' fields."));
+    }
+    let workflowResult = null;
+    if (resolvedVersion.ref !== "local" && options.sourceRepo) {
+      const workflowSpinner = logger.spinner("Syncing workflow files...");
+      workflowSpinner.start();
+      const workflowRef = resolvedVersion.isRelease && resolvedVersion.version ? formatTag(resolvedVersion.version) : resolvedVersion.ref;
+      workflowResult = await syncWorkflows(targetDir, workflowRef, options.sourceRepo);
+      workflowSpinner.stop();
+    }
+    const hookResult = await installPreCommitHook(targetDir);
+    const summaryLines = [];
+    console.log();
+    console.log(pc6.bold("Sync complete:"));
+    console.log();
+    const agentsMdPath = formatPath(path13.join(targetDir, "AGENTS.md"));
+    if (result.agentsMd.merged) {
+      const label = context.commandName === "sync" ? "(updated)" : "(merged)";
+      console.log(`  ${pc6.green("+")} ${agentsMdPath} ${pc6.dim(label)}`);
+      summaryLines.push(`- \`AGENTS.md\` ${label}`);
+    } else {
+      console.log(`  ${pc6.green("+")} ${agentsMdPath} ${pc6.dim("(created)")}`);
+      summaryLines.push("- `AGENTS.md` (created)");
+    }
+    for (const targetResult of result.targets) {
+      const config = getTargetConfig(targetResult.target);
+      if (config.instructionsFile) {
+        const instructionsPath = targetResult.instructionsMd.location === "root" ? formatPath(path13.join(targetDir, config.instructionsFile)) : formatPath(path13.join(targetDir, config.dir, config.instructionsFile));
+        const instructionsRelPath = targetResult.instructionsMd.location === "root" ? config.instructionsFile : `${config.dir}/${config.instructionsFile}`;
+        if (targetResult.instructionsMd.created) {
+          console.log(`  ${pc6.green("+")} ${instructionsPath} ${pc6.dim("(created)")}`);
+          summaryLines.push(`- \`${instructionsRelPath}\` (created)`);
+        } else if (targetResult.instructionsMd.updated) {
+          const hint = targetResult.instructionsMd.contentMerged ? "(content merged into AGENTS.md, reference added)" : "(reference added)";
+          console.log(`  ${pc6.yellow("~")} ${instructionsPath} ${pc6.dim(hint)}`);
+          summaryLines.push(`- \`${instructionsRelPath}\` ${hint}`);
+        } else {
+          console.log(`  ${pc6.dim("-")} ${instructionsPath} ${pc6.dim("(unchanged)")}`);
+          summaryLines.push(`- \`${instructionsRelPath}\` (unchanged)`);
+        }
+      }
+      const skillsPath = formatPath(path13.join(targetDir, config.dir, "skills"));
+      const skillsRelPath = `${config.dir}/skills/`;
+      const newSkills = result.skills.synced.filter((s) => !previousSkills.includes(s)).sort();
+      const updatedSkills = result.skills.modified.filter((s) => previousSkills.includes(s)).sort();
+      const removedSkills = orphanResult.deleted.sort();
+      const skillsHadChanges = newSkills.length > 0 || updatedSkills.length > 0 || removedSkills.length > 0;
+      const skillsStatusIcon = skillsHadChanges ? pc6.green("+") : pc6.dim("-");
+      const skillsStatusLabel = skillsHadChanges ? "(updated)" : "(unchanged)";
+      console.log(
+        `  ${skillsStatusIcon} ${skillsPath}/ ${pc6.dim(`(total: ${result.skills.synced.length} skills, ${targetResult.skills.copied} files) ${skillsStatusLabel}`)}`
+      );
+      summaryLines.push(
+        `- \`${skillsRelPath}\` (total: ${result.skills.synced.length} skills, ${targetResult.skills.copied} files) ${skillsStatusLabel}`
+      );
+      const MAX_ITEMS_DEFAULT = 5;
+      const shouldExpand = options.expandChanges === true;
+      const formatSkillList = (skills, icon, colorFn, label, mdLabel) => {
+        if (skills.length === 0) return;
+        const maxDisplay = shouldExpand ? skills.length : MAX_ITEMS_DEFAULT;
+        const displaySkills = skills.slice(0, maxDisplay);
+        const hiddenCount = skills.length - displaySkills.length;
+        for (const skill of displaySkills) {
+          const skillPath = formatPath(path13.join(targetDir, config.dir, "skills", skill));
+          const skillRelPath = `${config.dir}/skills/${skill}/`;
+          console.log(`    ${colorFn(icon)} ${skillPath}/ ${pc6.dim(`(${label})`)}`);
+          summaryLines.push(`  - \`${skillRelPath}\` (${mdLabel})`);
+        }
+        if (hiddenCount > 0) {
+          console.log(`    ${pc6.dim(`  ... ${hiddenCount} more ${label}`)}`);
+          summaryLines.push(`  - ... ${hiddenCount} more ${mdLabel}`);
+        }
+      };
+      formatSkillList(newSkills, "+", pc6.green, "new", "new");
+      formatSkillList(updatedSkills, "~", pc6.yellow, "updated", "updated");
+      for (const skill of removedSkills) {
+        const orphanPath = formatPath(path13.join(targetDir, config.dir, "skills", skill));
+        const orphanRelPath = `${config.dir}/skills/${skill}/`;
+        console.log(`    ${pc6.red("-")} ${orphanPath}/ ${pc6.dim("(removed)")}`);
+        summaryLines.push(`  - \`${orphanRelPath}\` (removed)`);
+      }
+      if (orphanResult.skipped.length > 0) {
+        for (const skill of orphanResult.skipped) {
+          const orphanPath = formatPath(path13.join(targetDir, config.dir, "skills", skill));
+          const orphanRelPath = `${config.dir}/skills/${skill}/`;
+          console.log(`    ${pc6.yellow("!")} ${orphanPath}/ ${pc6.dim("(orphaned but skipped)")}`);
+          summaryLines.push(`  - \`${orphanRelPath}\` (orphaned but skipped)`);
+        }
+      }
+      if (result.rules && result.rules.claudeFiles.length > 0 && targetResult.target === "claude") {
+        const rulesPath = formatPath(path13.join(targetDir, config.dir, "rules"));
+        const rulesRelPath = `${config.dir}/rules/`;
+        const rulesCount = result.rules.claudeFiles.length;
+        const newRules = result.rules.synced.filter((r) => !previousRules.includes(r)).sort();
+        const updatedRules = result.rules.modified.filter((r) => previousRules.includes(r)).sort();
+        const rulesHadChanges = newRules.length > 0 || updatedRules.length > 0;
+        const rulesStatusIcon = rulesHadChanges ? pc6.green("+") : pc6.dim("-");
+        const rulesStatusLabel = rulesHadChanges ? "(updated)" : "(unchanged)";
+        console.log(
+          `  ${rulesStatusIcon} ${rulesPath}/ ${pc6.dim(`(total: ${rulesCount} rules) ${rulesStatusLabel}`)}`
+        );
+        summaryLines.push(`- \`${rulesRelPath}\` (total: ${rulesCount} rules) ${rulesStatusLabel}`);
+        const formatRuleList = (rules, icon, colorFn, label, mdLabel) => {
+          if (rules.length === 0) return;
+          const maxDisplay = shouldExpand ? rules.length : MAX_ITEMS_DEFAULT;
+          const displayRules = rules.slice(0, maxDisplay);
+          const hiddenCount = rules.length - displayRules.length;
+          for (const rule of displayRules) {
+            const rulePath = formatPath(path13.join(targetDir, config.dir, "rules", rule));
+            const ruleRelPath = `${config.dir}/rules/${rule}`;
+            console.log(`    ${colorFn(icon)} ${rulePath} ${pc6.dim(`(${label})`)}`);
+            summaryLines.push(`  - \`${ruleRelPath}\` (${mdLabel})`);
+          }
+          if (hiddenCount > 0) {
+            console.log(`    ${pc6.dim(`  ... ${hiddenCount} more ${label}`)}`);
+            summaryLines.push(`  - ... ${hiddenCount} more ${mdLabel}`);
+          }
+        };
+        formatRuleList(newRules, "+", pc6.green, "new", "new");
+        formatRuleList(updatedRules, "~", pc6.yellow, "updated", "updated");
+      }
+      if (result.rules?.codexUpdated && targetResult.target === "codex") {
+        const rulesCount = result.rules.synced.length;
+        console.log(
+          `  ${pc6.green("+")} ${pc6.dim("AGENTS.md rules section")} ${pc6.dim(`(${rulesCount} rules concatenated)`)}`
+        );
+        summaryLines.push(`- AGENTS.md rules section (${rulesCount} rules concatenated)`);
+        const newRules = result.rules.synced.filter((r) => !previousRules.includes(r)).sort();
+        const updatedRules = result.rules.modified.filter((r) => previousRules.includes(r)).sort();
+        const formatCodexRuleList = (rules, icon, colorFn, label, mdLabel) => {
+          if (rules.length === 0) return;
+          const maxDisplay = shouldExpand ? rules.length : MAX_ITEMS_DEFAULT;
+          const displayRules = rules.slice(0, maxDisplay);
+          const hiddenCount = rules.length - displayRules.length;
+          for (const rule of displayRules) {
+            console.log(`    ${colorFn(icon)} ${rule} ${pc6.dim(`(${label})`)}`);
+            summaryLines.push(`  - \`${rule}\` (${mdLabel})`);
+          }
+          if (hiddenCount > 0) {
+            console.log(`    ${pc6.dim(`  ... ${hiddenCount} more ${label}`)}`);
+            summaryLines.push(`  - ... ${hiddenCount} more ${mdLabel}`);
+          }
+        };
+        formatCodexRuleList(newRules, "+", pc6.green, "new", "new");
+        formatCodexRuleList(updatedRules, "~", pc6.yellow, "updated", "updated");
+      }
+    }
+    if (workflowResult) {
+      for (const filename of workflowResult.created) {
+        const workflowPath = formatPath(path13.join(targetDir, ".github/workflows", filename));
+        console.log(`  ${pc6.green("+")} ${workflowPath} ${pc6.dim("(created)")}`);
+        summaryLines.push(`- \`.github/workflows/${filename}\` (created)`);
+      }
+      for (const filename of workflowResult.updated) {
+        const workflowPath = formatPath(path13.join(targetDir, ".github/workflows", filename));
+        console.log(`  ${pc6.yellow("~")} ${workflowPath} ${pc6.dim("(updated)")}`);
+        summaryLines.push(`- \`.github/workflows/${filename}\` (updated)`);
+      }
+      for (const filename of workflowResult.unchanged) {
+        const workflowPath = formatPath(path13.join(targetDir, ".github/workflows", filename));
+        console.log(`  ${pc6.dim("-")} ${workflowPath} ${pc6.dim("(unchanged)")}`);
+        summaryLines.push(`- \`.github/workflows/${filename}\` (unchanged)`);
+      }
+    }
+    const lockfilePath = formatPath(path13.join(targetDir, ".agent-conf", "agent-conf.lock"));
+    console.log(`  ${pc6.green("+")} ${lockfilePath}`);
+    summaryLines.push("- `.agent-conf/lockfile.json` (updated)");
+    const hookPath = formatPath(path13.join(targetDir, ".git/hooks/pre-commit"));
+    if (hookResult.installed) {
+      if (hookResult.alreadyExisted && !hookResult.wasUpdated) {
+        console.log(`  ${pc6.dim("-")} ${hookPath} ${pc6.dim("(unchanged)")}`);
+        summaryLines.push("- `.git/hooks/pre-commit` (unchanged)");
+      } else if (hookResult.wasUpdated) {
+        console.log(`  ${pc6.yellow("~")} ${hookPath} ${pc6.dim("(updated)")}`);
+        summaryLines.push("- `.git/hooks/pre-commit` (updated)");
+      } else {
+        console.log(`  ${pc6.green("+")} ${hookPath} ${pc6.dim("(installed)")}`);
+        summaryLines.push("- `.git/hooks/pre-commit` (installed)");
+      }
+    } else if (hookResult.alreadyExisted) {
+      console.log(`  ${pc6.yellow("!")} ${hookPath} ${pc6.dim("(skipped - custom hook exists)")}`);
+      summaryLines.push("- `.git/hooks/pre-commit` (skipped - custom hook exists)");
+    }
+    console.log();
+    console.log(pc6.dim(`Source: ${formatSourceString(resolvedSource.source)}`));
+    if (resolvedVersion.version) {
+      console.log(pc6.dim(`Version: ${resolvedVersion.version}`));
+    }
+    if (targets.length > 1) {
+      console.log(pc6.dim(`Targets: ${targets.join(", ")}`));
+    }
+    if (options.summaryFile) {
+      const sourceStr = formatSourceString(resolvedSource.source);
+      const versionStr = resolvedVersion.version ? `v${resolvedVersion.version}` : resolvedVersion.ref;
+      const summary = `## Changes
+
+${summaryLines.join("\n")}
+
+---
+**Source:** ${sourceStr}
+**Version:** ${versionStr}
+`;
+      await fs13.writeFile(options.summaryFile, summary, "utf-8");
+    }
+    prompts4.outro(pc6.green("Done!"));
+  } catch (error) {
+    syncSpinner.fail("Sync failed");
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  } finally {
+    if (tempDir) await removeTempDir(tempDir);
+  }
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const logger = createLogger();
+  console.log();
+  prompts5.intro(pc7.bold("agent-conf init"));
+  const targetDir = await resolveTargetDirectory();
+  const targets = await parseAndValidateTargets(options.target);
+  const status = await getSyncStatus(targetDir);
+  if (status.schemaError) {
+    logger.error(status.schemaError);
+    process.exit(1);
+  }
+  if (status.schemaWarning) {
+    logger.warn(status.schemaWarning);
+  }
+  if (status.hasSynced && !options.yes) {
+    const shouldContinue = await prompts5.confirm({
+      message: "This repository has already been synced. Do you want to sync again?"
+    });
+    if (prompts5.isCancel(shouldContinue) || !shouldContinue) {
+      prompts5.cancel("Operation cancelled");
+      process.exit(0);
+    }
+  }
+  const resolvedVersion = await resolveVersion(options, status, "init", options.source);
+  const { resolvedSource, tempDir, repository } = await resolveSource(options, resolvedVersion);
+  const shouldOverride = await promptMergeOrOverride(status, options, tempDir);
+  await checkModifiedFilesBeforeSync(targetDir, targets, options, tempDir);
+  await performSync({
+    targetDir,
+    resolvedSource,
+    resolvedVersion,
+    shouldOverride,
+    targets,
+    context: {
+      commandName: "init",
+      status
+    },
+    tempDir,
+    yes: options.yes,
+    sourceRepo: repository
+  });
+  if (!options.yes) {
+    await promptCompletionInstall();
+  }
+}
+
+// src/commands/status.ts
+import * as path14 from "path";
+import pc8 from "picocolors";
+async function statusCommand(options = {}) {
+  const targetDir = process.cwd();
+  const status = await getSyncStatus(targetDir);
+  console.log();
+  console.log(pc8.bold("agent-conf sync status"));
+  console.log();
+  if (!status.hasSynced) {
+    console.log(pc8.yellow("Not synced"));
+    console.log();
+    console.log(pc8.dim("Run `agent-conf init` to sync engineering standards to this repository."));
+    console.log();
+    return;
+  }
+  const lockfile = status.lockfile;
+  console.log(`${pc8.green("Synced")}`);
+  console.log();
+  console.log(pc8.bold("Source:"));
+  console.log(`  ${formatSourceString(lockfile.source)}`);
+  console.log();
+  console.log(pc8.bold("Last synced:"));
+  const syncedAt = new Date(lockfile.synced_at);
+  console.log(`  ${syncedAt.toLocaleString()}`);
+  console.log();
+  console.log(pc8.bold("Content:"));
+  console.log(`  AGENTS.md: ${status.agentsMdExists ? pc8.green("present") : pc8.red("missing")}`);
+  console.log(`  Skills: ${lockfile.content.skills.length} synced`);
+  if (lockfile.content.skills.length > 0) {
+    for (const skill of lockfile.content.skills) {
+      console.log(`    - ${skill}`);
+    }
+  }
+  console.log();
+  if (options.check) {
+    const targets = lockfile.content.targets ?? ["claude"];
+    const allFiles = await checkAllManagedFiles(targetDir, targets);
+    const modifiedFiles = allFiles.filter((f) => f.hasChanges);
+    console.log(pc8.bold("File integrity:"));
+    if (modifiedFiles.length === 0) {
+      console.log(`  ${pc8.green("\u2713")} All managed files are unchanged`);
+    } else {
+      console.log(`  ${pc8.yellow("!")} ${modifiedFiles.length} file(s) manually modified:`);
+      for (const file of modifiedFiles) {
+        const label = file.type === "agents" ? "(global block)" : "";
+        console.log(`    ${pc8.yellow("~")} ${file.path} ${pc8.dim(label)}`);
+      }
+      console.log();
+      console.log(pc8.dim("  These files will be overwritten on next sync. To preserve changes,"));
+      console.log(pc8.dim("  copy them elsewhere before running `agent-conf sync`."));
+    }
+    console.log();
+  }
+  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();
+}
+
+// src/commands/sync.ts
+import * as prompts6 from "@clack/prompts";
+import pc9 from "picocolors";
+async function syncCommand(options) {
+  const logger = createLogger();
+  console.log();
+  prompts6.intro(pc9.bold("agent-conf sync"));
+  if (options.pinned && options.ref) {
+    logger.error("Cannot use --pinned with --ref. Choose one.");
+    process.exit(1);
+  }
+  if (options.pinned && options.local !== void 0) {
+    logger.error("Cannot use --pinned with --local.");
+    process.exit(1);
+  }
+  const targetDir = await resolveTargetDirectory();
+  const targets = await parseAndValidateTargets(options.target);
+  const status = await getSyncStatus(targetDir);
+  if (status.schemaError) {
+    logger.error(status.schemaError);
+    process.exit(1);
+  }
+  if (status.schemaWarning) {
+    logger.warn(status.schemaWarning);
+  }
+  if (!status.hasSynced) {
+    logger.warn(
+      "This repository has not been synced yet. Consider running 'agent-conf init' first."
+    );
+  }
+  let sourceRepo = options.source;
+  if (!sourceRepo && status.lockfile?.source.type === "github") {
+    sourceRepo = status.lockfile.source.repository;
+  }
+  const resolvedVersion = await resolveVersion(options, status, "sync", sourceRepo);
+  if (!options.pinned && !options.ref && !options.local && status.lockfile?.pinned_version) {
+    const currentVersion = status.lockfile.pinned_version;
+    if (resolvedVersion.version) {
+      const comparison = compareVersions(currentVersion, resolvedVersion.version);
+      console.log();
+      console.log(`Canonical source: ${pc9.cyan(sourceRepo)}`);
+      console.log(`Latest release: ${pc9.cyan(resolvedVersion.version)}`);
+      console.log(`Pinned version: ${pc9.cyan(currentVersion)}`);
+      if (comparison >= 0) {
+        console.log(`  ${pc9.green("\u2713")} Up to date`);
+        console.log();
+        prompts6.outro(pc9.green("Already up to date!"));
+        return;
+      }
+      console.log(
+        `  ${pc9.yellow("\u2192")} Update available: ${currentVersion} \u2192 ${resolvedVersion.version}`
+      );
+      console.log();
+      if (!options.yes) {
+        const shouldUpdate = await prompts6.confirm({
+          message: "Proceed with update?",
+          initialValue: true
+        });
+        if (prompts6.isCancel(shouldUpdate) || !shouldUpdate) {
+          prompts6.cancel("Sync cancelled");
+          process.exit(0);
+        }
+      }
+    }
+  }
+  if (options.ref && status.lockfile?.pinned_version) {
+    const currentVersion = status.lockfile.pinned_version;
+    if (resolvedVersion.version && currentVersion !== resolvedVersion.version) {
+      logger.info(`Updating version: ${currentVersion} \u2192 ${resolvedVersion.version}`);
+    }
+  }
+  const optionsWithSource = sourceRepo ? { ...options, source: sourceRepo } : options;
+  const { resolvedSource, tempDir, repository } = await resolveSource(
+    optionsWithSource,
+    resolvedVersion
+  );
+  const shouldOverride = await promptMergeOrOverride(status, options, tempDir);
+  await checkModifiedFilesBeforeSync(targetDir, targets, options, tempDir);
+  await performSync({
+    targetDir,
+    resolvedSource,
+    resolvedVersion,
+    shouldOverride,
+    targets,
+    context: {
+      commandName: "sync",
+      status
+    },
+    tempDir,
+    yes: options.yes,
+    sourceRepo: repository,
+    summaryFile: options.summaryFile,
+    expandChanges: options.expandChanges
+  });
+}
+
+// src/commands/upgrade-cli.ts
+import { execSync as execSync2 } from "child_process";
+import * as prompts7 from "@clack/prompts";
+import pc10 from "picocolors";
+var NPM_PACKAGE_NAME = "agent-conf";
+async function getLatestNpmVersion() {
+  const response = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch package info: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.version;
+}
+async function upgradeCliCommand(options) {
+  const logger = createLogger();
+  const currentVersion = getCliVersion();
+  console.log();
+  prompts7.intro(pc10.bold("agent-conf upgrade-cli"));
+  const spinner = logger.spinner("Checking for CLI updates...");
+  spinner.start();
+  let latestVersion;
+  try {
+    latestVersion = await getLatestNpmVersion();
+    spinner.stop();
+  } catch (error) {
+    spinner.fail("Failed to check for CLI updates");
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  console.log();
+  console.log(`Current version: ${pc10.cyan(currentVersion)}`);
+  console.log(`Latest version:  ${pc10.cyan(latestVersion)}`);
+  const needsUpdate = compareVersions(currentVersion, latestVersion) < 0;
+  if (!needsUpdate) {
+    console.log();
+    prompts7.outro(pc10.green("CLI is already up to date!"));
+    return;
+  }
+  console.log();
+  console.log(`${pc10.yellow("\u2192")} Update available: ${currentVersion} \u2192 ${latestVersion}`);
+  console.log();
+  if (!options.yes) {
+    const shouldUpdate = await prompts7.confirm({
+      message: "Proceed with CLI upgrade?",
+      initialValue: true
+    });
+    if (prompts7.isCancel(shouldUpdate) || !shouldUpdate) {
+      prompts7.cancel("Upgrade cancelled");
+      process.exit(0);
+    }
+  }
+  const installSpinner = logger.spinner("Upgrading CLI...");
+  installSpinner.start();
+  try {
+    execSync2(`npm install -g ${NPM_PACKAGE_NAME}@latest`, {
+      stdio: "pipe"
+    });
+    installSpinner.succeed("CLI upgraded");
+    console.log();
+    prompts7.outro(pc10.green(`CLI upgraded to ${latestVersion}!`));
+  } catch (error) {
+    installSpinner.fail("Upgrade failed");
+    logger.error(error instanceof Error ? error.message : String(error));
+    logger.info(`
+You can try manually: npm install -g ${NPM_PACKAGE_NAME}@latest`);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+if (handleCompletion()) {
+  process.exit(0);
+}
+async function warnIfCliOutdated() {
+  try {
+    const cwd = process.cwd();
+    const gitRoot = await getGitRoot(cwd);
+    if (!gitRoot) return;
+    const mismatch = await checkCliVersionMismatch(gitRoot);
+    if (mismatch) {
+      console.log();
+      console.log(
+        pc11.yellow(
+          `\u26A0 CLI is outdated: v${mismatch.currentVersion} installed, but repo was synced with v${mismatch.lockfileVersion}`
+        )
+      );
+      console.log(pc11.yellow("  Run: agent-conf upgrade-cli"));
+      console.log();
+    }
+  } catch {
+  }
+}
+function createCli() {
+  const program = new Command();
+  program.name("agent-conf").description("Sync company engineering standards from agent-conf repository").version(getCliVersion()).hook("preAction", async () => {
+    await warnIfCliOutdated();
+  });
+  program.command("init").description("Initialize or sync agent-conf standards to the current repository").option(
+    "-s, --source <repo>",
+    "Canonical repository in owner/repo format (e.g., acme/standards)"
+  ).option("--local [path]", "Use local canonical repository (auto-discover or specify path)").option("-y, --yes", "Non-interactive mode (merge by default)").option("--override", "Override existing AGENTS.md instead of merging").option("--ref <ref>", "GitHub ref/version to sync from (default: latest release)").option("-t, --target <targets...>", "Target platforms (claude, codex)", ["claude"]).action(
+    async (options) => {
+      await initCommand(options);
+    }
+  );
+  program.command("sync").description("Sync content from canonical repository (fetches latest by default)").option(
+    "-s, --source <repo>",
+    "Canonical repository in owner/repo format (e.g., acme/standards)"
+  ).option("--local [path]", "Use local canonical repository (auto-discover or specify path)").option("-y, --yes", "Non-interactive mode (merge by default)").option("--override", "Override existing AGENTS.md instead of merging").option("--ref <ref>", "GitHub ref/version to sync from").option("--pinned", "Use lockfile version without fetching latest").option("-t, --target <targets...>", "Target platforms (claude, codex)", ["claude"]).option("--summary-file <path>", "Write sync summary to file (markdown, for CI)").option("--expand-changes", "Show all items in output (default: first 5)").action(
+    async (options) => {
+      await syncCommand(options);
+    }
+  );
+  program.command("status").description("Show current sync status").option("-c, --check", "Check for manually modified skill files").action(async (options) => {
+    await statusCommand(options);
+  });
+  program.command("check").description("Check if managed files have been modified").option("-q, --quiet", "Minimal output, just exit code").action(async (options) => {
+    await checkCommand(options);
+  });
+  program.command("upgrade-cli").description("Upgrade the agent-conf CLI to the latest version").option("-y, --yes", "Non-interactive mode").action(async (options) => {
+    await upgradeCliCommand(options);
+  });
+  const configCmd = program.command("config").description("Manage global CLI configuration");
+  configCmd.command("show").description("Show all configuration values").action(async () => {
+    await configShowCommand();
+  });
+  configCmd.command("get <key>").description("Get a configuration value").action(async (key) => {
+    await configGetCommand(key);
+  });
+  configCmd.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+    await configSetCommand(key, value);
+  });
+  configCmd.action(async () => {
+    await configShowCommand();
+  });
+  const completionCmd = program.command("completion").description("Manage shell completions (bash, zsh, fish)");
+  completionCmd.command("install").description("Install shell completions for your current shell").action(async () => {
+    await installCompletion();
+  });
+  completionCmd.command("uninstall").description("Remove shell completions").action(async () => {
+    await uninstallCompletion();
+  });
+  completionCmd.action(async () => {
+    await installCompletion();
+  });
+  const canonicalCmd = program.command("canonical").description("Manage canonical repositories");
+  canonicalCmd.command("init").description("Scaffold a new canonical repository structure").option("-n, --name <name>", "Name for the canonical repository").option("-o, --org <organization>", "Organization name").option("-d, --dir <directory>", "Target directory (default: current)").option("--marker-prefix <prefix>", "Marker prefix (default: agent-conf)").option("--no-examples", "Skip example skill creation").option("--rules-dir <directory>", "Rules directory (e.g., 'rules')").option("-y, --yes", "Non-interactive mode").action(
+    async (options) => {
+      await canonicalInitCommand({
+        name: options.name,
+        org: options.org,
+        dir: options.dir,
+        markerPrefix: options.markerPrefix,
+        includeExamples: options.examples,
+        rulesDir: options.rulesDir,
+        yes: options.yes
+      });
+    }
+  );
+  canonicalCmd.action(() => {
+    canonicalCmd.help();
+  });
+  program.action(() => {
+    program.help();
+  });
+  return program;
+}
+
+// src/index.ts
+var cli = createCli();
+cli.parse(process.argv);
+//# sourceMappingURL=index.js.map