@callmeradical/augy 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,10 @@
 # augy
 
-**Homebrew for AI agent skills** — install, version, update, and rollback skills across OpenCode, Claude, and Codex from a single CLI.
+[![npm](https://img.shields.io/npm/v/@callmeradical/augy?label=%40callmeradical%2Faugy&color=7c3aed)](https://www.npmjs.com/package/@callmeradical/augy)
+[![license](https://img.shields.io/github/license/callmeradical/augy)](LICENSE)
+[![node](https://img.shields.io/node/v/@callmeradical/augy)](package.json)
+
+**Homebrew for AI agent skills.** No marketplace. No accounts. No central service. Just Git repos, a lockfile, and full control over what runs in your agents.
 
 ```
 augy install tdd              # install by name via a tap
@@ -11,53 +15,87 @@ augy rollback tdd abc1234     # something broke — go back
 
 ---
 
+## The philosophy
+
+Other skill managers route you through a hosted registry — a central service you have to trust, that can go down, that doesn't work with private repos, and that you can't use behind a firewall.
+
+augy works differently. **Skills are just files in Git repos. GitHub is the registry.**
+
+- Any GitHub repo is a valid skill source — public or private
+- `~/.augy/registry.json` is your lockfile — a plain JSON file you can read, diff, commit, and share
+- No account required. No API key for the registry. No SaaS dependency
+- Works in enterprise environments, behind proxies, with internal repos
+- You decide which repos to trust — not a third-party curation team
+
+The tap system is Homebrew's model: register a repo once, install skills by name. Remove the tap and you've unregistered the source. Simple, transparent, yours.
+
+---
+
 ## Install
 
 ```bash
-npm install -g augy
+npm install -g @callmeradical/augy
 ```
 
+> The npm package is `@callmeradical/augy`. The CLI command is `augy`.
+
 Requires Node.js ≥ 18.
 
 ---
 
 ## How it works
 
-Skills are directories containing a `SKILL.md` file that an AI agent loads as context. augy tracks which skills you have installed, where they came from (GitHub), and what version (commit SHA) is on disk — then lets you update, diff, and roll back just like a package manager.
+Skills are directories containing a `SKILL.md` file that an AI agent loads as context. augy tracks which skills you have installed, where they came from (a GitHub path), and what exact version (commit SHA) is on disk — then lets you update, diff, and roll back just like a package manager.
 
 **Supported agents**
 
-| Agent | Default skills path |
-|---|---|
-| OpenCode | `~/.opencode/skills/` |
-| Claude | `~/.claude/skills/` |
-| Codex | `~/.codex/skills/` (or `$CODEX_HOME/skills`) |
+augy auto-detects which agents are installed on your machine and pre-selects them in the install prompt. All 33 are supported:
 
-A single skill can be deployed to multiple agents simultaneously.
+Claude · OpenCode · Codex · Cursor · Windsurf · GitHub Copilot · Gemini CLI · Goose · Amp · Roo Code · Cline · Kiro · Kimi CLI · Kilo Code · Trae · Trae CN · Augment · OpenHands · Replit · Crush · Antigravity · Droid · OpenClaw · CodeBuddy · Command Code · Kode · Mistral Vibe · Mux · OpenClaude IDE · Qoder · Qwen Code · Neovate · AdaL
+
+A single skill can be deployed to multiple agents simultaneously and stays in sync on every update.
+
+---
+
+## Quick start
+
+```bash
+# 1. Add a tap — a GitHub repo you trust
+augy tap add mattpocock/skills
+
+# 2. See what's available
+augy search
+
+# 3. Install by name
+augy install tdd
+
+# Already have skills installed manually? Bring them under augy management:
+augy scan
+```
 
 ---
 
 ## Commands
 
 ### `augy install [url]`
-Install skills from a GitHub URL, `owner/repo[/path]` shorthand, or a bare name resolved via a registered tap.
+Install skills from a GitHub URL, `owner/repo[/path]` shorthand, or a bare name resolved via a tap. When a repo contains multiple skills, shows a filterable picker.
 
 ```bash
+augy install tdd                                          # via tap
+augy install mattpocock/skills                            # all skills in a repo
 augy install https://github.com/mattpocock/skills/tree/main
-augy install mattpocock/skills/skills/engineering/tdd
-augy install tdd                    # resolves via taps
-augy install tdd --agent opencode   # target a specific agent
+augy install tdd --agent opencode claude                  # specific agents
 ```
 
 ### `augy scan`
-Find skills already on disk that augy doesn't know about. Auto-detects provenance via git remotes and `SKILL.md` frontmatter, groups results into *detected* vs *no provenance found* with filesystem paths shown for unknown skills. Imports them into the registry.
+Walk all agent skill directories, find skills augy doesn't know about, auto-detect their GitHub source via git remotes and `SKILL.md` frontmatter, and import them into the registry. Skills without a detectable source show their filesystem path so you can look them up.
 
 ```bash
 augy scan
 ```
 
 ### `augy update [skill]`
-Check all installed skills for upstream SHA drift. Shows a list of available upgrades, lets you select which to apply, archives the current version before overwriting.
+Check all installed skills for upstream SHA drift. Archives the current version, then deploys the new one.
 
 ```bash
 augy update              # check + upgrade everything
@@ -70,19 +108,19 @@ Interactive file-level diff browser. Three modes:
 ```bash
 augy diff tdd                    # installed ↔ upstream HEAD
 augy diff tdd abc1234            # installed ↔ specific SHA
-augy diff tdd abc1234 def5678    # two local archives
+augy diff tdd abc1234 def5678    # two local archives side-by-side
 ```
 
 ### `augy rollback <skill> [sha]`
-Restore a skill to any previously archived version.
+Restore a skill to any previously archived version. Without a SHA, shows an interactive picker.
 
 ```bash
-augy rollback tdd                # interactive version picker
-augy rollback tdd abc1234        # specific SHA (short or full)
+augy rollback tdd
+augy rollback tdd abc1234
 ```
 
 ### `augy list`
-Show all installed skills, their SHAs, agents, and update status.
+Show all installed skills, their SHAs, agents, and version history.
 
 ```bash
 augy list
@@ -90,32 +128,63 @@ augy list --json    # raw registry JSON
 ```
 
 ### `augy info <skill>`
-Full metadata: source, SHA, agents with paths, version history, and a preview of the skill description.
+Full metadata: source, SHA, agents with paths, version history, and a description preview from `SKILL.md`.
 
 ```bash
 augy info tdd
 ```
 
 ### `augy search [query]`
-Search all registered taps for available skills.
+Search all registered taps for available skills. Shows install status and whether each skill is up to date.
 
 ```bash
-augy search           # full index
+augy search           # full index across all taps
 augy search tdd       # filter by name
 ```
 
 ### `augy tap add|remove|list`
-Manage trusted repos (taps) — once added, skills can be installed by bare name.
+Manage trusted repos. Once tapped, install by bare name.
 
 ```bash
 augy tap add mattpocock/skills
+augy tap add org/internal-skills          # private repos work too
 augy tap add mattpocock/skills --path skills/engineering
 augy tap list
 augy tap remove mattpocock/skills
 ```
 
+### `augy bundle`
+Generate an `augy.json` manifest from your currently installed skills. Commit this file so teammates can reproduce your exact skill set with `augy sync`.
+
+```bash
+augy bundle                       # writes ./augy.json
+augy bundle --output ~/augy.json  # custom path
+augy bundle --include-untracked   # include skills with no known source
+```
+
+`augy.json` format:
+```json
+{
+  "version": 1,
+  "skills": {
+    "tdd": "mattpocock/skills/skills/engineering/tdd",
+    "commit": "anomalyco/agent-skills/skills/commit"
+  }
+}
+```
+
+### `augy sync [path]`
+Install and update skills from an `augy.json` manifest. Skills in your registry but not in the manifest are left alone — nothing is auto-removed.
+
+```bash
+augy sync                         # reads ./augy.json
+augy sync ~/team/augy.json        # explicit path
+augy sync --dry-run               # preview changes without applying
+augy sync --agent opencode claude # target specific agents
+```
+
 ### `augy set-source <skill> <url>`
-Attach a GitHub source to a skill imported without one (e.g. via `augy scan`). Enables updates and diffs. Accepts tree and blob URLs.
+Attach a GitHub source to a skill imported without one. Accepts tree and blob URLs. Enables updates, diffs, and rollbacks.
 
 ```bash
 augy set-source commit https://github.com/owner/repo/tree/main/skills/commit
@@ -129,7 +198,7 @@ augy uninstall tdd
 ```
 
 ### `augy pin|unpin <skill>`
-Pin a skill to skip it during `augy update`.
+Pin a skill to freeze it at the current version, skipping it during `augy update`.
 
 ```bash
 augy pin tdd
@@ -140,22 +209,25 @@ augy unpin tdd
 
 ## Taps
 
-Taps are trusted GitHub repos containing skills. Add one and install by name without knowing the full URL:
+Taps are GitHub repos you trust as skill sources. The tap system is how augy stays decentralized — there is no central index, just repos you choose to register.
 
 ```bash
-augy tap add mattpocock/skills
-augy install tdd        # resolves to mattpocock/skills automatically
+augy tap add mattpocock/skills        # public repo
+augy tap add your-org/private-skills  # private repo — works the same way
+augy install tdd                      # resolves via taps automatically
 ```
 
+Any GitHub repo containing a `SKILL.md` file (or subdirectories that do) is a valid tap. The source of truth is GitHub. augy just tracks what you've installed and from where.
+
 ---
 
 ## Version storage
 
-Every upgrade archives the current skill to `~/.augy/versions/<skill>/<sha>/` before overwriting it — giving you a full local snapshot history to diff or rollback to at any time.
+Every upgrade archives the current skill files to `~/.augy/versions/<skill>/<sha>/` before overwriting. No external service required — snapshots live on your machine.
 
 ```
 ~/.augy/
-  registry.json             ← lockfile (human-readable JSON)
+  registry.json             ← lockfile — plain JSON, human-readable
   versions/
     tdd/
       7afa86d.../           ← snapshot before last upgrade
@@ -170,13 +242,13 @@ Every upgrade archives the current skill to `~/.augy/versions/<skill>/<sha>/` be
 |---|---|---|
 | `AUGY_HOME` | `~/.augy` | Override augy's home directory |
 | `CODEX_HOME` | `~/.codex` | Override Codex agent path |
-| `GITHUB_TOKEN` | — | Raise GitHub API rate limit from 60 to 5000 req/hr |
+| `GITHUB_TOKEN` | — | Raise GitHub API rate limit from 60 → 5,000 req/hr |
 
 ---
 
 ## Docs
 
-Full documentation at **[augy.dev](https://augy.dev)** *(coming soon — see `docs/` for the source)*.
+Full documentation at **[callmeradical.github.io/augy](https://callmeradical.github.io/augy)**
 
 ---
 

package/dist/bundle-L4LMJLKN.js

@@ -0,0 +1,49 @@
+import {
+  listSkills,
+  readRegistry
+} from "./chunk-JM4VVAHN.js";
+
+// src/commands/bundle.ts
+import { outro, spinner } from "@clack/prompts";
+import chalk from "chalk";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import { cwd } from "process";
+var DEFAULT_FILENAME = "augy.json";
+async function bundleCommand(opts) {
+  const registry = await readRegistry();
+  const skills = listSkills(registry);
+  if (!skills.length) {
+    console.log(chalk.dim("No skills installed. Nothing to bundle."));
+    return;
+  }
+  const tracked = skills.filter((s2) => s2.source);
+  const untracked = skills.filter((s2) => !s2.source);
+  const bundle = {
+    version: 1,
+    skills: {}
+  };
+  for (const skill of tracked) {
+    bundle.skills[skill.name] = skill.source;
+  }
+  if (opts.includeUntracked) {
+    for (const skill of untracked) {
+      bundle.skills[skill.name] = "";
+    }
+  }
+  const outputPath = opts.output ?? join(cwd(), DEFAULT_FILENAME);
+  const s = spinner();
+  s.start(`Writing ${chalk.cyan(outputPath)}\u2026`);
+  await writeFile(outputPath, JSON.stringify(bundle, null, 2) + "\n", "utf8");
+  s.stop(`${chalk.green("\u2713")} Bundle written  ${chalk.dim(outputPath)}`);
+  const skillCount = Object.keys(bundle.skills).length;
+  const skippedNote = !opts.includeUntracked && untracked.length > 0 ? chalk.dim(`
+  ${untracked.length} untracked skill(s) omitted \u2014 use --include-untracked to add them`) : "";
+  outro(
+    `${chalk.bold(String(skillCount))} skill(s) bundled${skippedNote}
+` + chalk.dim("  Commit augy.json to share this skill set with your team.\n") + chalk.dim("  Teammates run `augy sync` to install from it.")
+  );
+}
+export {
+  bundleCommand
+};

package/dist/{chunk-YXCEZ3EY.js → chunk-HZSFPII7.js}

@@ -1,11 +1,11 @@
 import {
   discoverSkills,
   parseGitHubUrl
-} from "./chunk-EU54UQ4C.js";
+} from "./chunk-2E5SVRSR.js";
 import {
   listTaps,
   tapKey
-} from "./chunk-ZW6ZKHTF.js";
+} from "./chunk-JM4VVAHN.js";
 
 // src/taps.ts
 async function searchTaps(registry, query) {

package/dist/{chunk-ZW6ZKHTF.js → chunk-JM4VVAHN.js}

@@ -112,6 +112,12 @@ function addTap(registry, tap) {
 function removeTap(registry, key) {
   delete registry.taps[key];
 }
+function getHomeConfig(registry) {
+  return registry.home;
+}
+function setHomeConfig(registry, config) {
+  registry.home = config;
+}
 
 export {
   __commonJS,
@@ -132,5 +138,7 @@ export {
   getTap,
   listTaps,
   addTap,
-  removeTap
+  removeTap,
+  getHomeConfig,
+  setHomeConfig
 };

package/dist/{chunk-UJX6VJ3S.js → chunk-RBF4Q6N4.js}

@@ -1,7 +1,7 @@
 import {
   __commonJS,
   __toESM
-} from "./chunk-ZW6ZKHTF.js";
+} from "./chunk-JM4VVAHN.js";
 
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS({

package/dist/chunk-V5GA2ZHU.js

@@ -0,0 +1,65 @@
+// src/agents.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+function h(p) {
+  return p.startsWith("~") ? join(homedir(), p.slice(1)) : p;
+}
+function codexSkillsPath() {
+  const codexHome = process.env["CODEX_HOME"];
+  return codexHome ? join(codexHome, "skills") : h("~/.codex/skills");
+}
+var AGENTS = [
+  // ── Tier 1: most widely used ────────────────────────────────────
+  { id: "opencode", name: "OpenCode", skillsPath: h("~/.opencode/skills"), skillFile: "SKILL.md" },
+  { id: "claude", name: "Claude", skillsPath: h("~/.claude/skills"), skillFile: "SKILL.md" },
+  { id: "codex", name: "Codex", skillsPath: codexSkillsPath(), skillFile: "SKILL.md" },
+  { id: "cursor", name: "Cursor", skillsPath: h("~/.cursor/skills"), skillFile: "SKILL.md" },
+  { id: "windsurf", name: "Windsurf", skillsPath: h("~/.codeium/windsurf/skills"), skillFile: "SKILL.md" },
+  { id: "copilot", name: "GitHub Copilot", skillsPath: h("~/.github/skills"), skillFile: "SKILL.md" },
+  { id: "gemini", name: "Gemini CLI", skillsPath: h("~/.gemini/skills"), skillFile: "SKILL.md" },
+  { id: "goose", name: "Goose", skillsPath: h("~/.goose/skills"), skillFile: "SKILL.md" },
+  { id: "amp", name: "Amp", skillsPath: h("~/.agents/skills"), skillFile: "SKILL.md" },
+  { id: "roo", name: "Roo Code", skillsPath: h("~/.roo/skills"), skillFile: "SKILL.md" },
+  { id: "cline", name: "Cline", skillsPath: h("~/.cline/skills"), skillFile: "SKILL.md" },
+  // ── Tier 2: growing ─────────────────────────────────────────────
+  { id: "kiro", name: "Kiro", skillsPath: h("~/.kiro/skills"), skillFile: "SKILL.md" },
+  { id: "kimi", name: "Kimi CLI", skillsPath: h("~/.kimi/skills"), skillFile: "SKILL.md" },
+  { id: "kilocode", name: "Kilo Code", skillsPath: h("~/.kilocode/skills"), skillFile: "SKILL.md" },
+  { id: "trae", name: "Trae", skillsPath: h("~/.trae/skills"), skillFile: "SKILL.md" },
+  { id: "trae-cn", name: "Trae CN", skillsPath: h("~/.trae-cn/skills"), skillFile: "SKILL.md" },
+  { id: "augment", name: "Augment", skillsPath: h("~/.augment/rules"), skillFile: "SKILL.md" },
+  { id: "openhands", name: "OpenHands", skillsPath: h("~/.openhands/skills"), skillFile: "SKILL.md" },
+  { id: "replit", name: "Replit", skillsPath: h("~/.replit/skills"), skillFile: "SKILL.md" },
+  { id: "crush", name: "Crush", skillsPath: h("~/.config/crush/skills"), skillFile: "SKILL.md" },
+  // ── Tier 3: long tail ───────────────────────────────────────────
+  { id: "antigravity", name: "Antigravity", skillsPath: h("~/.gemini/antigravity/skills"), skillFile: "SKILL.md" },
+  { id: "droid", name: "Droid", skillsPath: h("~/.factory/skills"), skillFile: "SKILL.md" },
+  { id: "openclaw", name: "OpenClaw", skillsPath: h("~/.openclaw/skills"), skillFile: "SKILL.md" },
+  { id: "codebuddy", name: "CodeBuddy", skillsPath: h("~/.codebuddy/skills"), skillFile: "SKILL.md" },
+  { id: "commandcode", name: "Command Code", skillsPath: h("~/.commandcode/skills"), skillFile: "SKILL.md" },
+  { id: "kode", name: "Kode", skillsPath: h("~/.kode/skills"), skillFile: "SKILL.md" },
+  { id: "mistralvibe", name: "Mistral Vibe", skillsPath: h("~/.vibe/skills"), skillFile: "SKILL.md" },
+  { id: "mux", name: "Mux", skillsPath: h("~/.mux/skills"), skillFile: "SKILL.md" },
+  { id: "openclaude", name: "OpenClaude IDE", skillsPath: h("~/.openclaude/skills"), skillFile: "SKILL.md" },
+  { id: "qoder", name: "Qoder", skillsPath: h("~/.qoder/skills"), skillFile: "SKILL.md" },
+  { id: "qwen", name: "Qwen Code", skillsPath: h("~/.qwen/skills"), skillFile: "SKILL.md" },
+  { id: "neovate", name: "Neovate", skillsPath: h("~/.neovate/skills"), skillFile: "SKILL.md" },
+  { id: "adal", name: "AdaL", skillsPath: h("~/.adal/skills"), skillFile: "SKILL.md" }
+];
+function agentById(id) {
+  return AGENTS.find((a) => a.id === id);
+}
+function agentSkillPath(agent, skillName) {
+  return join(agent.skillsPath, skillName);
+}
+function detectInstalledAgents() {
+  return AGENTS.filter((a) => existsSync(a.skillsPath));
+}
+
+export {
+  AGENTS,
+  agentById,
+  agentSkillPath,
+  detectInstalledAgents
+};

package/dist/{chunk-PX2LVUHV.js → chunk-Z4R7NYGP.js}

@@ -1,6 +1,6 @@
 import {
   versionArchivePath
-} from "./chunk-ZW6ZKHTF.js";
+} from "./chunk-JM4VVAHN.js";
 
 // src/versions.ts
 import { cp, mkdir, rm } from "fs/promises";
@@ -32,7 +32,7 @@ Archive path: ${src}`
 }
 async function pruneVersions(skillName, keepShas = []) {
   const { join } = await import("path");
-  const { versionArchivePath: archivePath, versionsDir } = await import("./registry-QVCNZXBZ.js");
+  const { versionArchivePath: archivePath, versionsDir } = await import("./registry-2B52E3ME.js");
   const skillVersionsDir = join(versionsDir(), skillName);
   if (!existsSync(skillVersionsDir)) return;
   const { readdir } = await import("fs/promises");

package/dist/{diff-KYSWUXMH.js → diff-JQ5L3GEO.js}

@@ -1,16 +1,16 @@
-import {
-  archiveExists
-} from "./chunk-PX2LVUHV.js";
 import {
   discoverSkills,
   parseGitHubUrl
-} from "./chunk-EU54UQ4C.js";
+} from "./chunk-2E5SVRSR.js";
+import {
+  archiveExists
+} from "./chunk-Z4R7NYGP.js";
 import {
   getSkill,
   readRegistry,
   shortSha,
   versionArchivePath
-} from "./chunk-ZW6ZKHTF.js";
+} from "./chunk-JM4VVAHN.js";
 
 // src/commands/diff.ts
 import { cancel, intro, isCancel, outro, select, spinner } from "@clack/prompts";

package/dist/home-TWK3PMCL.js

@@ -0,0 +1,205 @@
+import {
+  AGENTS,
+  agentSkillPath,
+  detectInstalledAgents
+} from "./chunk-V5GA2ZHU.js";
+import {
+  createSkillRecord,
+  getHomeConfig,
+  listSkills,
+  readRegistry,
+  setHomeConfig,
+  upsertSkill,
+  writeRegistry
+} from "./chunk-JM4VVAHN.js";
+
+// src/commands/home.ts
+import { intro, outro, spinner } from "@clack/prompts";
+import chalk from "chalk";
+import { cp, mkdir, readdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// src/git.ts
+import { execFile } from "child_process";
+function run(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+function repoToUrl(ownerRepoOrUrl) {
+  if (ownerRepoOrUrl.startsWith("https://") || ownerRepoOrUrl.startsWith("git@")) {
+    return ownerRepoOrUrl;
+  }
+  return `https://github.com/${ownerRepoOrUrl}.git`;
+}
+async function cloneRepo(url, destDir) {
+  await run("git", ["clone", "--depth=1", url, destDir]);
+}
+async function gitAddAll(dir) {
+  await run("git", ["-C", dir, "add", "-A"]);
+}
+async function gitCommit(dir, message) {
+  await run("git", ["-C", dir, "commit", "-m", message]);
+}
+async function gitPush(dir) {
+  await run("git", ["-C", dir, "push"]);
+}
+
+// src/commands/home.ts
+var DEFAULT_PATH = "augy.json";
+var DEFAULT_SKILLS_DIR = "skills";
+async function homeSetCommand(repo, opts = {}) {
+  const parts = repo.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid repo "${repo}" \u2014 expected owner/repo format (e.g. alice/my-skills)`);
+  }
+  const path = opts.path ?? DEFAULT_PATH;
+  const skillsPath = opts.skillsPath ?? DEFAULT_SKILLS_DIR;
+  const registry = await readRegistry();
+  setHomeConfig(registry, { repo, path, skillsPath });
+  await writeRegistry(registry);
+  outro(
+    `${chalk.green("\u2713")} Home repo set to ${chalk.cyan(repo)}
+` + chalk.dim(`  manifest : ${path}
+`) + chalk.dim(`  skills   : ${skillsPath}/`)
+  );
+}
+async function homeShowCommand() {
+  const registry = await readRegistry();
+  const home = getHomeConfig(registry);
+  if (!home) {
+    console.log(chalk.dim("No home repo configured. Run `augy home set <owner/repo>` to set one."));
+    return;
+  }
+  console.log(`${chalk.bold("Home repo")}  ${chalk.cyan(home.repo)}`);
+  console.log(`${chalk.dim("manifest ")}  ${home.path}`);
+  console.log(`${chalk.dim("skills   ")}  ${home.skillsPath}/`);
+}
+async function homePushCommand() {
+  intro(chalk.bold("augy") + chalk.dim(" \u2014 home push"));
+  const registry = await readRegistry();
+  const home = getHomeConfig(registry);
+  if (!home) {
+    console.error(
+      chalk.red("No home repo configured.") + "\nRun `augy home set <owner/repo>` first."
+    );
+    process.exit(1);
+  }
+  const allSkills = listSkills(registry);
+  const authored = allSkills.filter((s3) => !s3.source);
+  const external = allSkills.filter((s3) => s3.source);
+  const cloneDir = join(tmpdir(), `augy-home-push-${Date.now()}`);
+  const s = spinner();
+  s.start(`Cloning ${chalk.cyan(home.repo)}\u2026`);
+  await cloneRepo(repoToUrl(home.repo), cloneDir);
+  s.stop(`${chalk.green("\u2713")} Cloned`);
+  const homeRepo = home.repo;
+  for (const skill of authored) {
+    const sourcePath = Object.values(skill.agents).find((a) => a.active && existsSync(a.path))?.path;
+    if (!sourcePath) continue;
+    const destPath = home.skillsPath ? join(cloneDir, home.skillsPath, skill.name) : join(cloneDir, skill.name);
+    await mkdir(destPath, { recursive: true });
+    await cp(sourcePath, destPath, { recursive: true, force: true });
+    const newSource = `https://github.com/${homeRepo}/tree/main/${home.skillsPath ? home.skillsPath + "/" : ""}${skill.name}`;
+    skill.source = newSource;
+    upsertSkill(registry, skill);
+  }
+  const bundle = { version: 1, skills: {} };
+  for (const skill of allSkills) {
+    bundle.skills[skill.name] = skill.source;
+  }
+  await writeFile(
+    join(cloneDir, home.path),
+    JSON.stringify(bundle, null, 2) + "\n",
+    "utf8"
+  );
+  const s2 = spinner();
+  s2.start("Committing and pushing\u2026");
+  await gitAddAll(cloneDir);
+  const skillCount = allSkills.length;
+  const authoredNote = authored.length ? ` (${authored.length} authored)` : "";
+  await gitCommit(cloneDir, `chore: update skills via augy \u2014 ${skillCount} skill(s)${authoredNote}`);
+  await gitPush(cloneDir);
+  s2.stop(`${chalk.green("\u2713")} Pushed`);
+  if (authored.length) await writeRegistry(registry);
+  outro(
+    `${chalk.bold(String(skillCount))} skill(s) saved to ${chalk.cyan(home.repo)}
+` + (authored.length ? chalk.dim(`  ${authored.length} authored skill(s) committed + source registered
+`) : "") + chalk.dim(`  Run \`augy home pull\` on a new machine to restore.`)
+  );
+}
+async function homePullCommand(opts = {}) {
+  intro(chalk.bold("augy") + chalk.dim(" \u2014 home pull"));
+  const registry = await readRegistry();
+  const home = getHomeConfig(registry);
+  if (!home) {
+    console.error(
+      chalk.red("No home repo configured.") + "\nRun `augy home set <owner/repo>` first."
+    );
+    process.exit(1);
+  }
+  const cloneDir = join(tmpdir(), `augy-home-pull-${Date.now()}`);
+  const s = spinner();
+  s.start(`Cloning ${chalk.cyan(home.repo)}\u2026`);
+  await cloneRepo(repoToUrl(home.repo), cloneDir);
+  s.stop(`${chalk.green("\u2713")} Cloned`);
+  const targetAgents = opts.agent?.length ? AGENTS.filter((a) => opts.agent.includes(a.id)) : detectInstalledAgents();
+  if (!targetAgents.length) {
+    console.error(chalk.red("No agents detected. Install an agent or use --agent to specify one."));
+    process.exit(1);
+  }
+  const skillsDir = home.skillsPath ? join(cloneDir, home.skillsPath) : cloneDir;
+  const authoredInstalled = [];
+  if (existsSync(skillsDir)) {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const skillDirs = entries.filter((e) => e.isDirectory());
+    for (const dir of skillDirs) {
+      const skillName = dir.name;
+      const srcPath = join(skillsDir, skillName);
+      const source = `https://github.com/${home.repo}/tree/main/${home.skillsPath ? home.skillsPath + "/" : ""}${skillName}`;
+      if (opts.dryRun) {
+        console.log(`  ${chalk.cyan("+")} ${skillName}  ${chalk.dim("(authored)")}`);
+        continue;
+      }
+      const agentPaths = {};
+      for (const agent of targetAgents) {
+        const dest = agentSkillPath(agent, skillName);
+        await mkdir(dest, { recursive: true });
+        await cp(srcPath, dest, { recursive: true, force: true });
+        agentPaths[agent.id] = dest;
+      }
+      const record = createSkillRecord({
+        name: skillName,
+        source,
+        gigetSource: "",
+        sha: "home",
+        agentIds: targetAgents.map((a) => a.id),
+        agentPaths
+      });
+      upsertSkill(registry, record);
+      authoredInstalled.push(skillName);
+    }
+  }
+  const manifestPath = join(cloneDir, home.path);
+  if (existsSync(manifestPath)) {
+    const { syncCommand } = await import("./sync-QQFXUXCN.js");
+    await syncCommand(manifestPath, opts);
+  }
+  if (!opts.dryRun && authoredInstalled.length) {
+    await writeRegistry(registry);
+  }
+  if (opts.dryRun) {
+    outro(chalk.dim("Dry run \u2014 no changes made."));
+  }
+}
+export {
+  homePullCommand,
+  homePushCommand,
+  homeSetCommand,
+  homeShowCommand
+};