thought-cabinet 0.1.13 → 0.2.0

package/dist/index.js

@@ -68,11 +68,29 @@ function saveConfigFile(config, configFile) {
   console.log(chalk.green("Config saved successfully"));
 }
 function getDefaultConfigDir() {
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(process.env.HOME || "", ".config");
-  return path.join(xdgConfigHome, "thought-cabinet");
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, "thought-cabinet");
+  }
+  return path.join(process.env.HOME || "", ".thought-cabinet");
+}
+function getLegacyConfigDir() {
+  return path.join(process.env.HOME || "", ".config", "thought-cabinet");
+}
+function resolveConfigDir() {
+  const newDir = getDefaultConfigDir();
+  const newConfigPath = path.join(newDir, ConfigResolver.DEFAULT_CONFIG_FILE);
+  if (fs.existsSync(newConfigPath)) {
+    return newDir;
+  }
+  const legacyDir = getLegacyConfigDir();
+  const legacyConfigPath = path.join(legacyDir, ConfigResolver.DEFAULT_CONFIG_FILE);
+  if (fs.existsSync(legacyConfigPath)) {
+    return legacyDir;
+  }
+  return newDir;
 }
 function getDefaultConfigPath() {
-  return path.join(getDefaultConfigDir(), ConfigResolver.DEFAULT_CONFIG_FILE);
+  return path.join(resolveConfigDir(), ConfigResolver.DEFAULT_CONFIG_FILE);
 }
 
 // src/commands/thoughts/utils/config.ts
@@ -249,7 +267,7 @@ function getRepoRoot(cwd) {
 
 // src/commands/thoughts/utils/paths.ts
 function getDefaultThoughtsRepo() {
-  return path3.join(os.homedir(), "thoughts");
+  return path3.join(getDefaultConfigDir(), "thoughts");
 }
 function expandPath(filePath) {
   if (filePath.startsWith("~/")) {
@@ -929,7 +947,7 @@ function resolveExitCode(exitCode, timedOut) {
 async function executeHook(hook, input, env = {}) {
   const startTime = Date.now();
   const timeoutMs = (hook.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1e3;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -958,7 +976,7 @@ async function executeHook(hook, input, env = {}) {
     child.on("close", (exitCode) => {
       clearTimeout(timer);
       const duration = Date.now() - startTime;
-      resolve2({
+      resolve3({
         success: exitCode === 0 && !timedOut,
         exitCode: resolveExitCode(exitCode, timedOut),
         stdout: stdout.trim(),
@@ -970,7 +988,7 @@ async function executeHook(hook, input, env = {}) {
     child.on("error", (error) => {
       clearTimeout(timer);
       const duration = Date.now() - startTime;
-      resolve2({
+      resolve3({
         success: false,
         exitCode: 1,
         stdout: stdout.trim(),
@@ -1971,32 +1989,365 @@ async function thoughtsPruneCommand(options) {
   }
 }
 
-// src/commands/thoughts/profile/create.ts
+// src/commands/thoughts/migrate.ts
+import fs12 from "fs";
+import path14 from "path";
 import chalk11 from "chalk";
 import * as p2 from "@clack/prompts";
+
+// src/commands/agent/registry.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+var home = homedir();
+var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+var agents = {
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    configDir: ".claude",
+    globalConfigDir: claudeHome,
+    detectInstalled: async () => existsSync(claudeHome)
+  },
+  codebuddy: {
+    name: "codebuddy",
+    displayName: "CodeBuddy Code",
+    configDir: ".codebuddy",
+    globalConfigDir: join(home, ".codebuddy"),
+    detectInstalled: async () => existsSync(join(process.cwd(), ".codebuddy")) || existsSync(join(home, ".codebuddy"))
+  }
+};
+function getAllAgents() {
+  return Object.values(agents);
+}
+function isValidAgentType(value) {
+  return value in agents;
+}
+
+// src/commands/agent/constants.ts
+var CANONICAL_DIR = ".thought-cabinet";
+var CATEGORY_SUBDIRS = {
+  skills: "skills",
+  commands: "commands",
+  agents: "agents"
+};
+
+// src/commands/thoughts/migrate.ts
+function planMigration(homeDir) {
+  const home2 = homeDir || process.env.HOME || "";
+  const newConfigDir = path14.join(home2, ".thought-cabinet");
+  const legacyConfigDir = path14.join(home2, ".config", "thought-cabinet");
+  const legacyConfigPath = path14.join(legacyConfigDir, "config.json");
+  const newConfigPath = path14.join(newConfigDir, "config.json");
+  if (fs12.existsSync(newConfigPath)) {
+    return null;
+  }
+  if (!fs12.existsSync(legacyConfigPath)) {
+    return null;
+  }
+  let config;
+  try {
+    config = JSON.parse(fs12.readFileSync(legacyConfigPath, "utf8"));
+  } catch {
+    return null;
+  }
+  const thoughts = config.thoughts;
+  if (!thoughts) {
+    return null;
+  }
+  const moves = [];
+  moves.push({
+    from: legacyConfigPath,
+    to: path14.join(newConfigDir, "config.json"),
+    label: "Config file"
+  });
+  for (const dir of ["agents", "skills"]) {
+    const src = path14.join(legacyConfigDir, dir);
+    if (fs12.existsSync(src)) {
+      moves.push({
+        from: src,
+        to: path14.join(newConfigDir, dir),
+        label: `${dir}/ directory`
+      });
+    }
+  }
+  if (thoughts.thoughtsRepo) {
+    const expandedThoughtsRepo = expandPath(thoughts.thoughtsRepo);
+    const newDefaultThoughtsRepo = path14.join(newConfigDir, "thoughts");
+    if (fs12.existsSync(expandedThoughtsRepo) && expandedThoughtsRepo !== newDefaultThoughtsRepo && !expandedThoughtsRepo.startsWith(newConfigDir + path14.sep)) {
+      moves.push({
+        from: expandedThoughtsRepo,
+        to: newDefaultThoughtsRepo,
+        label: `Default thoughts repo (${thoughts.thoughtsRepo})`
+      });
+    }
+  }
+  if (thoughts.profiles) {
+    for (const [name, profile] of Object.entries(thoughts.profiles)) {
+      const expandedProfileRepo = expandPath(profile.thoughtsRepo);
+      const newProfileRepo = path14.join(newConfigDir, `thoughts-${name}`);
+      if (fs12.existsSync(expandedProfileRepo) && expandedProfileRepo !== newProfileRepo && !expandedProfileRepo.startsWith(newConfigDir + path14.sep)) {
+        moves.push({
+          from: expandedProfileRepo,
+          to: newProfileRepo,
+          label: `Profile "${name}" thoughts repo (${profile.thoughtsRepo})`
+        });
+      }
+    }
+  }
+  const affectedRepos = thoughts.repoMappings ? Object.keys(thoughts.repoMappings) : [];
+  return {
+    moves,
+    newConfigDir,
+    legacyConfigDir,
+    config,
+    affectedRepos
+  };
+}
+function executeMigration(plan) {
+  fs12.mkdirSync(plan.newConfigDir, { recursive: true });
+  for (const move of plan.moves) {
+    const destDir = path14.dirname(move.to);
+    fs12.mkdirSync(destDir, { recursive: true });
+    fs12.renameSync(move.from, move.to);
+  }
+  const thoughts = plan.config.thoughts;
+  if (thoughts) {
+    thoughts.thoughtsRepo = path14.join(plan.newConfigDir, "thoughts");
+    if (thoughts.profiles) {
+      for (const [name, profile] of Object.entries(thoughts.profiles)) {
+        profile.thoughtsRepo = path14.join(plan.newConfigDir, `thoughts-${name}`);
+      }
+    }
+  }
+  const newConfigPath = path14.join(plan.newConfigDir, "config.json");
+  fs12.writeFileSync(newConfigPath, JSON.stringify(plan.config, null, 2));
+}
+function refreshRepoSymlinks(config, affectedRepos) {
+  const refreshed = [];
+  const skipped = [];
+  for (const repoPath of affectedRepos) {
+    if (!fs12.existsSync(repoPath)) {
+      skipped.push(repoPath);
+      continue;
+    }
+    const mapping = config.repoMappings[repoPath];
+    const mappedName = getRepoNameFromMapping(mapping);
+    if (!mappedName) {
+      skipped.push(repoPath);
+      continue;
+    }
+    const profileConfig = resolveProfileForRepo(
+      {
+        thoughtsRepo: config.thoughtsRepo,
+        reposDir: config.reposDir,
+        globalDir: config.globalDir,
+        user: config.user,
+        repoMappings: config.repoMappings,
+        profiles: config.profiles
+      },
+      repoPath
+    );
+    createThoughtsDirectoryStructure(profileConfig, mappedName, config.user);
+    setupThoughtsDirectory({
+      repoPath,
+      profileConfig,
+      mappedName,
+      user: config.user
+    });
+    refreshed.push(repoPath);
+  }
+  return { refreshed, skipped };
+}
+function refreshGlobalAgentSymlinks(legacyConfigDir, newConfigDir, agentList) {
+  let refreshed = 0;
+  const agents2 = [];
+  const agentsToScan = agentList || getAllAgents();
+  for (const agent of agentsToScan) {
+    if (!agent.globalConfigDir) continue;
+    let agentTouched = false;
+    for (const category of Object.values(CATEGORY_SUBDIRS)) {
+      const categoryDir = path14.join(agent.globalConfigDir, category);
+      if (!fs12.existsSync(categoryDir)) continue;
+      const entries = fs12.readdirSync(categoryDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path14.join(categoryDir, entry.name);
+        let stats;
+        try {
+          stats = fs12.lstatSync(entryPath);
+        } catch {
+          continue;
+        }
+        if (!stats.isSymbolicLink()) continue;
+        const linkTarget = fs12.readlinkSync(entryPath);
+        const resolvedTarget = path14.resolve(path14.dirname(entryPath), linkTarget);
+        if (!resolvedTarget.startsWith(legacyConfigDir + path14.sep) && resolvedTarget !== legacyConfigDir) {
+          continue;
+        }
+        const relativeToCfg = path14.relative(legacyConfigDir, resolvedTarget);
+        const newTarget = path14.join(newConfigDir, relativeToCfg);
+        if (!fs12.existsSync(newTarget)) continue;
+        fs12.unlinkSync(entryPath);
+        const newRelative = path14.relative(path14.dirname(entryPath), newTarget);
+        fs12.symlinkSync(newRelative, entryPath);
+        refreshed++;
+        agentTouched = true;
+      }
+    }
+    if (agentTouched) {
+      agents2.push(agent.displayName);
+    }
+  }
+  return { refreshed, agents: agents2 };
+}
+function previewGlobalAgentSymlinks(legacyConfigDir, agentList) {
+  const entries = [];
+  const agentsToScan = agentList || getAllAgents();
+  for (const agent of agentsToScan) {
+    if (!agent.globalConfigDir) continue;
+    for (const category of Object.values(CATEGORY_SUBDIRS)) {
+      const categoryDir = path14.join(agent.globalConfigDir, category);
+      if (!fs12.existsSync(categoryDir)) continue;
+      const dirEntries = fs12.readdirSync(categoryDir, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        const entryPath = path14.join(categoryDir, entry.name);
+        try {
+          const stats = fs12.lstatSync(entryPath);
+          if (!stats.isSymbolicLink()) continue;
+          const linkTarget = fs12.readlinkSync(entryPath);
+          const resolvedTarget = path14.resolve(path14.dirname(entryPath), linkTarget);
+          if (resolvedTarget.startsWith(legacyConfigDir + path14.sep)) {
+            entries.push(entryPath);
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  return entries;
+}
+async function thoughtsMigrateCommand(options) {
+  const newConfigDir = getDefaultConfigDir();
+  const legacyConfigDir = getLegacyConfigDir();
+  const newConfigPath = path14.join(newConfigDir, ConfigResolver.DEFAULT_CONFIG_FILE);
+  const legacyConfigPath = path14.join(legacyConfigDir, ConfigResolver.DEFAULT_CONFIG_FILE);
+  if (!fs12.existsSync(legacyConfigPath)) {
+    if (fs12.existsSync(newConfigPath)) {
+      p2.log.info("Configuration is already at the new location.");
+      return;
+    }
+    p2.log.info("No configuration found to migrate.");
+    return;
+  }
+  if (legacyConfigDir === newConfigDir) {
+    p2.log.info("Configuration is already at the expected location.");
+    return;
+  }
+  const plan = planMigration();
+  if (!plan) {
+    p2.log.info("Nothing to migrate.");
+    return;
+  }
+  p2.intro(chalk11.blue("Migrate Thought Cabinet Configuration"));
+  p2.log.step("Migration plan:");
+  for (const move of plan.moves) {
+    p2.log.message(`  ${move.label}`);
+    p2.log.message(chalk11.gray(`    ${move.from} \u2192 ${move.to}`));
+  }
+  if (options.dryRun) {
+    if (plan.affectedRepos.length > 0) {
+      p2.log.step("Repo symlinks that would be refreshed:");
+      for (const repo of plan.affectedRepos) {
+        if (fs12.existsSync(repo)) {
+          p2.log.message(chalk11.gray(`  ${repo}/thoughts/`));
+        } else {
+          p2.log.message(chalk11.gray(`  ${repo}/thoughts/ (skipped \u2014 repo not found)`));
+        }
+      }
+    }
+    const agentPreview = previewGlobalAgentSymlinks(plan.legacyConfigDir);
+    if (agentPreview.length > 0) {
+      p2.log.step("Global agent symlinks that would be refreshed:");
+      for (const entry of agentPreview) {
+        p2.log.message(chalk11.gray(`  ${entry}`));
+      }
+    }
+    p2.log.info("Dry run \u2014 no changes made.");
+    return;
+  }
+  const confirm5 = await p2.confirm({
+    message: "Proceed with migration?",
+    initialValue: true
+  });
+  if (p2.isCancel(confirm5) || !confirm5) {
+    p2.cancel("Migration cancelled.");
+    return;
+  }
+  executeMigration(plan);
+  for (const move of plan.moves) {
+    p2.log.success(`Moved: ${move.label}`);
+  }
+  try {
+    const remaining = fs12.readdirSync(plan.legacyConfigDir);
+    if (remaining.length === 0) {
+      fs12.rmdirSync(plan.legacyConfigDir);
+      p2.log.info(`Removed empty directory: ${plan.legacyConfigDir}`);
+    }
+  } catch {
+  }
+  if (plan.affectedRepos.length > 0) {
+    const config = loadThoughtsConfig({ configFile: path14.join(plan.newConfigDir, "config.json") });
+    if (config) {
+      p2.log.step("Refreshing thoughts symlinks in registered repos...");
+      const repoResult = refreshRepoSymlinks(config, plan.affectedRepos);
+      for (const repo of repoResult.refreshed) {
+        p2.log.success(`Refreshed: ${repo}`);
+      }
+      for (const repo of repoResult.skipped) {
+        p2.log.warn(`Skipped (not found): ${repo}`);
+      }
+    }
+  }
+  p2.log.step("Refreshing global agent symlinks...");
+  const agentResult = refreshGlobalAgentSymlinks(plan.legacyConfigDir, plan.newConfigDir);
+  if (agentResult.refreshed > 0) {
+    p2.log.success(
+      `Refreshed ${agentResult.refreshed} symlink(s) for: ${agentResult.agents.join(", ")}`
+    );
+  } else {
+    p2.log.info("No global agent symlinks needed updating.");
+  }
+  p2.outro(chalk11.green("Migration complete!"));
+}
+
+// src/commands/thoughts/profile/create.ts
+import chalk12 from "chalk";
+import path15 from "path";
+import * as p3 from "@clack/prompts";
 async function profileCreateCommand(profileName, options) {
   try {
     if (!options.repo || !options.reposDir || !options.globalDir) {
       if (!process.stdin.isTTY) {
-        p2.log.error("Not running in interactive terminal.");
-        p2.log.info("Provide all options: --repo, --repos-dir, --global-dir");
+        p3.log.error("Not running in interactive terminal.");
+        p3.log.info("Provide all options: --repo, --repos-dir, --global-dir");
         process.exit(1);
       }
     }
     const config = loadThoughtsConfig(options);
     if (!config) {
-      p2.log.error("Thoughts not configured.");
-      p2.log.info('Run "thoughtcabinet init" first to set up the base configuration.');
+      p3.log.error("Thoughts not configured.");
+      p3.log.info('Run "thoughtcabinet init" first to set up the base configuration.');
       process.exit(1);
     }
     const sanitizedName = sanitizeProfileName(profileName);
     if (sanitizedName !== profileName) {
-      p2.log.warn(`Profile name sanitized: "${profileName}" \u2192 "${sanitizedName}"`);
+      p3.log.warn(`Profile name sanitized: "${profileName}" \u2192 "${sanitizedName}"`);
     }
-    p2.intro(chalk11.blue(`Creating Profile: ${sanitizedName}`));
+    p3.intro(chalk12.blue(`Creating Profile: ${sanitizedName}`));
     if (validateProfile(config, sanitizedName)) {
-      p2.log.error(`Profile "${sanitizedName}" already exists.`);
-      p2.log.info("Use a different name or delete the existing profile first.");
+      p3.log.error(`Profile "${sanitizedName}" already exists.`);
+      p3.log.info("Use a different name or delete the existing profile first.");
       process.exit(1);
     }
     let thoughtsRepo;
@@ -2007,35 +2358,35 @@ async function profileCreateCommand(profileName, options) {
       reposDir = options.reposDir;
       globalDir = options.globalDir;
     } else {
-      const defaultRepo = getDefaultThoughtsRepo() + `-${sanitizedName}`;
-      p2.log.info("Specify the thoughts repository location for this profile.");
-      const repoInput = await p2.text({
+      const defaultRepo = path15.join(getDefaultConfigDir(), `thoughts-${sanitizedName}`);
+      p3.log.info("Specify the thoughts repository location for this profile.");
+      const repoInput = await p3.text({
         message: "Thoughts repository:",
         initialValue: defaultRepo,
         placeholder: defaultRepo
       });
-      if (p2.isCancel(repoInput)) {
-        p2.cancel("Operation cancelled.");
+      if (p3.isCancel(repoInput)) {
+        p3.cancel("Operation cancelled.");
         process.exit(0);
       }
       thoughtsRepo = repoInput || defaultRepo;
-      const reposDirInput = await p2.text({
+      const reposDirInput = await p3.text({
         message: "Repository-specific thoughts directory:",
         initialValue: "repos",
         placeholder: "repos"
       });
-      if (p2.isCancel(reposDirInput)) {
-        p2.cancel("Operation cancelled.");
+      if (p3.isCancel(reposDirInput)) {
+        p3.cancel("Operation cancelled.");
         process.exit(0);
       }
       reposDir = reposDirInput || "repos";
-      const globalDirInput = await p2.text({
+      const globalDirInput = await p3.text({
         message: "Global thoughts directory:",
         initialValue: "global",
         placeholder: "global"
       });
-      if (p2.isCancel(globalDirInput)) {
-        p2.cancel("Operation cancelled.");
+      if (p3.isCancel(globalDirInput)) {
+        p3.cancel("Operation cancelled.");
         process.exit(0);
       }
       globalDir = globalDirInput || "global";
@@ -2050,56 +2401,56 @@ async function profileCreateCommand(profileName, options) {
     }
     config.profiles[sanitizedName] = profileConfig;
     saveThoughtsConfig(config, options);
-    p2.log.step("Initializing profile thoughts repository...");
+    p3.log.step("Initializing profile thoughts repository...");
     ensureThoughtsRepoExists(profileConfig);
-    p2.log.success(`Profile "${sanitizedName}" created successfully!`);
-    p2.note(
-      `Name: ${chalk11.cyan(sanitizedName)}
-Thoughts repository: ${chalk11.cyan(thoughtsRepo)}
-Repos directory: ${chalk11.cyan(reposDir)}
-Global directory: ${chalk11.cyan(globalDir)}`,
+    p3.log.success(`Profile "${sanitizedName}" created successfully!`);
+    p3.note(
+      `Name: ${chalk12.cyan(sanitizedName)}
+Thoughts repository: ${chalk12.cyan(thoughtsRepo)}
+Repos directory: ${chalk12.cyan(reposDir)}
+Global directory: ${chalk12.cyan(globalDir)}`,
       "Profile Configuration"
     );
-    p2.outro(
-      chalk11.gray("Next steps:\n") + chalk11.gray(`  1. Run "thoughtcabinet init --profile ${sanitizedName}" in a repository
-`) + chalk11.gray(`  2. Your thoughts will sync to the profile's repository`)
+    p3.outro(
+      chalk12.gray("Next steps:\n") + chalk12.gray(`  1. Run "thoughtcabinet init --profile ${sanitizedName}" in a repository
+`) + chalk12.gray(`  2. Your thoughts will sync to the profile's repository`)
     );
   } catch (error) {
-    p2.log.error(`Error creating profile: ${error}`);
+    p3.log.error(`Error creating profile: ${error}`);
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/profile/list.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 async function profileListCommand(options) {
   try {
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk12.red("Error: Thoughts not configured."));
+      console.error(chalk13.red("Error: Thoughts not configured."));
       process.exit(1);
     }
     if (options.json) {
       console.log(JSON.stringify(config.profiles || {}, null, 2));
       return;
     }
-    console.log(chalk12.blue("Thoughts Profiles"));
-    console.log(chalk12.gray("=".repeat(50)));
+    console.log(chalk13.blue("Thoughts Profiles"));
+    console.log(chalk13.gray("=".repeat(50)));
     console.log("");
-    console.log(chalk12.yellow("Default Configuration:"));
-    console.log(`  Thoughts repository: ${chalk12.cyan(config.thoughtsRepo)}`);
-    console.log(`  Repos directory: ${chalk12.cyan(config.reposDir)}`);
-    console.log(`  Global directory: ${chalk12.cyan(config.globalDir)}`);
+    console.log(chalk13.yellow("Default Configuration:"));
+    console.log(`  Thoughts repository: ${chalk13.cyan(config.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk13.cyan(config.reposDir)}`);
+    console.log(`  Global directory: ${chalk13.cyan(config.globalDir)}`);
     console.log("");
     if (!config.profiles || Object.keys(config.profiles).length === 0) {
-      console.log(chalk12.gray("No profiles configured."));
+      console.log(chalk13.gray("No profiles configured."));
       console.log("");
-      console.log(chalk12.gray("Create a profile with: thoughtcabinet profile create <name>"));
+      console.log(chalk13.gray("Create a profile with: thoughtcabinet profile create <name>"));
     } else {
-      console.log(chalk12.yellow(`Profiles (${Object.keys(config.profiles).length}):`));
+      console.log(chalk13.yellow(`Profiles (${Object.keys(config.profiles).length}):`));
       console.log("");
       Object.entries(config.profiles).forEach(([name, profile]) => {
-        console.log(chalk12.cyan(`  ${name}:`));
+        console.log(chalk13.cyan(`  ${name}:`));
         console.log(`    Thoughts repository: ${profile.thoughtsRepo}`);
         console.log(`    Repos directory: ${profile.reposDir}`);
         console.log(`    Global directory: ${profile.globalDir}`);
@@ -2107,30 +2458,30 @@ async function profileListCommand(options) {
       });
     }
   } catch (error) {
-    console.error(chalk12.red(`Error listing profiles: ${error}`));
+    console.error(chalk13.red(`Error listing profiles: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/profile/show.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 async function profileShowCommand(profileName, options) {
   try {
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk13.red("Error: Thoughts not configured."));
+      console.error(chalk14.red("Error: Thoughts not configured."));
       process.exit(1);
     }
     if (!validateProfile(config, profileName)) {
-      console.error(chalk13.red(`Error: Profile "${profileName}" not found.`));
+      console.error(chalk14.red(`Error: Profile "${profileName}" not found.`));
       console.error("");
-      console.error(chalk13.gray("Available profiles:"));
+      console.error(chalk14.gray("Available profiles:"));
       if (config.profiles) {
         Object.keys(config.profiles).forEach((name) => {
-          console.error(chalk13.gray(`  - ${name}`));
+          console.error(chalk14.gray(`  - ${name}`));
         });
       } else {
-        console.error(chalk13.gray("  (none)"));
+        console.error(chalk14.gray("  (none)"));
       }
       process.exit(1);
     }
@@ -2139,13 +2490,13 @@ async function profileShowCommand(profileName, options) {
       console.log(JSON.stringify(profile, null, 2));
       return;
     }
-    console.log(chalk13.blue(`Profile: ${profileName}`));
-    console.log(chalk13.gray("=".repeat(50)));
+    console.log(chalk14.blue(`Profile: ${profileName}`));
+    console.log(chalk14.gray("=".repeat(50)));
     console.log("");
-    console.log(chalk13.yellow("Configuration:"));
-    console.log(`  Thoughts repository: ${chalk13.cyan(profile.thoughtsRepo)}`);
-    console.log(`  Repos directory: ${chalk13.cyan(profile.reposDir)}`);
-    console.log(`  Global directory: ${chalk13.cyan(profile.globalDir)}`);
+    console.log(chalk14.yellow("Configuration:"));
+    console.log(`  Thoughts repository: ${chalk14.cyan(profile.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk14.cyan(profile.reposDir)}`);
+    console.log(`  Global directory: ${chalk14.cyan(profile.globalDir)}`);
     console.log("");
     let repoCount = 0;
     Object.values(config.repoMappings).forEach((mapping) => {
@@ -2153,32 +2504,32 @@ async function profileShowCommand(profileName, options) {
         repoCount++;
       }
     });
-    console.log(chalk13.yellow("Usage:"));
-    console.log(`  Repositories using this profile: ${chalk13.cyan(repoCount)}`);
+    console.log(chalk14.yellow("Usage:"));
+    console.log(`  Repositories using this profile: ${chalk14.cyan(repoCount)}`);
   } catch (error) {
-    console.error(chalk13.red(`Error showing profile: ${error}`));
+    console.error(chalk14.red(`Error showing profile: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/profile/delete.ts
-import chalk14 from "chalk";
-import * as p3 from "@clack/prompts";
+import chalk15 from "chalk";
+import * as p4 from "@clack/prompts";
 async function profileDeleteCommand(profileName, options) {
   try {
     if (!options.force && !process.stdin.isTTY) {
-      p3.log.error("Not running in interactive terminal.");
-      p3.log.info("Use --force flag to delete without confirmation.");
+      p4.log.error("Not running in interactive terminal.");
+      p4.log.info("Use --force flag to delete without confirmation.");
       process.exit(1);
     }
-    p3.intro(chalk14.blue(`Delete Profile: ${profileName}`));
+    p4.intro(chalk15.blue(`Delete Profile: ${profileName}`));
     const config = loadThoughtsConfig(options);
     if (!config) {
-      p3.log.error("Thoughts not configured.");
+      p4.log.error("Thoughts not configured.");
       process.exit(1);
     }
     if (!validateProfile(config, profileName)) {
-      p3.log.error(`Profile "${profileName}" not found.`);
+      p4.log.error(`Profile "${profileName}" not found.`);
       process.exit(1);
     }
     const usingRepos = [];
@@ -2188,27 +2539,27 @@ async function profileDeleteCommand(profileName, options) {
       }
     });
     if (usingRepos.length > 0 && !options.force) {
-      p3.log.error(`Profile "${profileName}" is in use by ${usingRepos.length} repository(ies):`);
+      p4.log.error(`Profile "${profileName}" is in use by ${usingRepos.length} repository(ies):`);
       usingRepos.forEach((repo) => {
-        p3.log.message(chalk14.gray(`  - ${repo}`));
+        p4.log.message(chalk15.gray(`  - ${repo}`));
       });
-      p3.log.warn("Options:");
-      p3.log.message(chalk14.gray('  1. Run "thoughtcabinet destroy" in each repository'));
-      p3.log.message(
-        chalk14.gray("  2. Use --force to delete anyway (repos will fall back to default config)")
+      p4.log.warn("Options:");
+      p4.log.message(chalk15.gray('  1. Run "thoughtcabinet destroy" in each repository'));
+      p4.log.message(
+        chalk15.gray("  2. Use --force to delete anyway (repos will fall back to default config)")
       );
       process.exit(1);
     }
     if (!options.force) {
-      p3.log.warn(`You are about to delete profile: ${chalk14.cyan(profileName)}`);
-      p3.log.message(chalk14.gray("This will remove the profile configuration."));
-      p3.log.message(chalk14.gray("The thoughts repository files will NOT be deleted."));
-      const confirmDelete = await p3.confirm({
+      p4.log.warn(`You are about to delete profile: ${chalk15.cyan(profileName)}`);
+      p4.log.message(chalk15.gray("This will remove the profile configuration."));
+      p4.log.message(chalk15.gray("The thoughts repository files will NOT be deleted."));
+      const confirmDelete = await p4.confirm({
         message: `Delete profile "${profileName}"?`,
         initialValue: false
       });
-      if (p3.isCancel(confirmDelete) || !confirmDelete) {
-        p3.cancel("Deletion cancelled.");
+      if (p4.isCancel(confirmDelete) || !confirmDelete) {
+        p4.cancel("Deletion cancelled.");
         return;
       }
     }
@@ -2217,13 +2568,13 @@ async function profileDeleteCommand(profileName, options) {
       delete config.profiles;
     }
     saveThoughtsConfig(config, options);
-    p3.log.success(`Profile "${profileName}" deleted`);
+    p4.log.success(`Profile "${profileName}" deleted`);
     if (usingRepos.length > 0) {
-      p3.log.warn("Repositories using this profile will fall back to default config");
+      p4.log.warn("Repositories using this profile will fall back to default config");
     }
-    p3.outro(chalk14.green("Done"));
+    p4.outro(chalk15.green("Done"));
   } catch (error) {
-    p3.log.error(`Error deleting profile: ${error}`);
+    p4.log.error(`Error deleting profile: ${error}`);
     process.exit(1);
   }
 }
@@ -2240,6 +2591,7 @@ function thoughtsCommand(program) {
   cmd.command("status").description("Show status of thoughts repository").option("--config-file <path>", "Path to config file").option("--fetch", "Fetch from remote before showing status").action(thoughtsStatusCommand);
   cmd.command("config").description("View or edit thoughts configuration").option("--edit", "Open configuration in editor").option("--json", "Output configuration as JSON").option("--config-file <path>", "Path to config file").action(thoughtsConfigCommand);
   cmd.command("prune").description("Remove stale repository mappings (directories that no longer exist)").option("--apply", "Apply changes (default is dry-run)").option("--config-file <path>", "Path to config file").action(thoughtsPruneCommand);
+  cmd.command("migrate").description("Migrate configuration from ~/.config/thought-cabinet/ to ~/.thought-cabinet/").option("--dry-run", "Show what would be migrated without making changes").option("--config-file <path>", "Path to legacy config file").action(thoughtsMigrateCommand);
   const profile = cmd.command("profile").description("Manage thoughts profiles");
   profile.command("create <name>").description("Create a new thoughts profile").option("--repo <path>", "Thoughts repository path").option("--repos-dir <name>", "Repos directory name").option("--global-dir <name>", "Global directory name").option("--config-file <path>", "Path to config file").action(profileCreateCommand);
   profile.command("list").description("List all thoughts profiles").option("--json", "Output as JSON").option("--config-file <path>", "Path to config file").action(profileListCommand);
@@ -2248,49 +2600,12 @@ function thoughtsCommand(program) {
 }
 
 // src/commands/agent/init.ts
-import fs12 from "fs";
-import path14 from "path";
-import chalk15 from "chalk";
-import * as p4 from "@clack/prompts";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+import chalk16 from "chalk";
+import * as p5 from "@clack/prompts";
 import { fileURLToPath } from "url";
-
-// src/commands/agent/registry.ts
-import { homedir } from "os";
-import { join } from "path";
-import { existsSync } from "fs";
-var home = homedir();
-var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
-var agents = {
-  "claude-code": {
-    name: "claude-code",
-    displayName: "Claude Code",
-    configDir: ".claude",
-    globalConfigDir: claudeHome,
-    detectInstalled: async () => existsSync(claudeHome)
-  },
-  codebuddy: {
-    name: "codebuddy",
-    displayName: "CodeBuddy Code",
-    configDir: ".codebuddy",
-    globalConfigDir: join(home, ".codebuddy"),
-    detectInstalled: async () => existsSync(join(process.cwd(), ".codebuddy")) || existsSync(join(home, ".codebuddy"))
-  }
-};
-function getAllAgents() {
-  return Object.values(agents);
-}
-async function detectInstalledAgents() {
-  const results = await Promise.all(
-    Object.entries(agents).map(async ([type, config]) => ({
-      type,
-      installed: await config.detectInstalled()
-    }))
-  );
-  return results.filter((r) => r.installed).map((r) => r.type);
-}
-function isValidAgentType(value) {
-  return value in agents;
-}
+import { cp as cp2, mkdir as mkdir2, readdir as readdir3 } from "fs/promises";
 
 // src/commands/agent/discovery.ts
 import { readdir, readFile } from "fs/promises";
@@ -2378,16 +2693,7 @@ async function discoverAllAssets(sourcePath) {
 // src/commands/agent/installer.ts
 import { mkdir, cp, readdir as readdir2, symlink as fsSymlink, lstat, rm, readlink } from "fs/promises";
 import { join as join3, basename, normalize, resolve, sep, relative, dirname } from "path";
-import { platform } from "os";
-
-// src/commands/agent/constants.ts
-var CATEGORY_SUBDIRS = {
-  skills: "skills",
-  commands: "commands",
-  agents: "agents"
-};
-
-// src/commands/agent/installer.ts
+import { homedir as homedir2, platform } from "os";
 function sanitizeName(name) {
   const sanitized = name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.-]+|[.-]+$/g, "");
   return sanitized.substring(0, 255) || "unnamed-asset";
@@ -2402,6 +2708,10 @@ function getAgentDir(agentType, category, scope, cwd) {
   const agentBase = scope === "global" && agent.globalConfigDir ? agent.globalConfigDir : join3(cwd || process.cwd(), agent.configDir);
   return join3(agentBase, CATEGORY_SUBDIRS[category]);
 }
+function getCanonicalDir(category, scope, cwd) {
+  const baseDir = scope === "global" ? homedir2() : cwd || process.cwd();
+  return join3(baseDir, CANONICAL_DIR, CATEGORY_SUBDIRS[category]);
+}
 async function cleanAndCreateDirectory(dirPath) {
   try {
     await rm(dirPath, { recursive: true, force: true });
@@ -2507,15 +2817,37 @@ async function installAssetForAgent(asset, agentType, options = {}) {
       await copyAsset(agentDir);
       return { success: true, path: agentDir, mode: "copy" };
     }
-    await rm(agentDir, { recursive: true, force: true });
-    await mkdir(dirname(agentDir), { recursive: true });
-    const symlinkCreated = await createSymlink(asset.sourcePath, agentDir);
-    if (!symlinkCreated) {
-      await cleanAndCreateDirectory(agentDir);
-      await copyAsset(agentDir);
-      return { success: true, path: agentDir, mode: "symlink", symlinkFailed: true };
+    if (scope === "project") {
+      const canonicalBase = getCanonicalDir(asset.category, scope, cwd);
+      const canonicalDir = join3(canonicalBase, assetName);
+      await cleanAndCreateDirectory(canonicalDir);
+      await copyAsset(canonicalDir);
+      await rm(agentDir, { recursive: true, force: true });
+      await mkdir(dirname(agentDir), { recursive: true });
+      const symlinkCreated = await createSymlink(canonicalDir, agentDir);
+      if (!symlinkCreated) {
+        await cleanAndCreateDirectory(agentDir);
+        await copyAsset(agentDir);
+        return {
+          success: true,
+          path: agentDir,
+          canonicalPath: canonicalDir,
+          mode: "symlink",
+          symlinkFailed: true
+        };
+      }
+      return { success: true, path: agentDir, canonicalPath: canonicalDir, mode: "symlink" };
+    } else {
+      await rm(agentDir, { recursive: true, force: true });
+      await mkdir(dirname(agentDir), { recursive: true });
+      const symlinkCreated = await createSymlink(asset.sourcePath, agentDir);
+      if (!symlinkCreated) {
+        await cleanAndCreateDirectory(agentDir);
+        await copyAsset(agentDir);
+        return { success: true, path: agentDir, mode: "symlink", symlinkFailed: true };
+      }
+      return { success: true, path: agentDir, mode: "symlink" };
     }
-    return { success: true, path: agentDir, mode: "symlink" };
   } catch (error) {
     return {
       success: false,
@@ -2527,216 +2859,318 @@ async function installAssetForAgent(asset, agentType, options = {}) {
 }
 
 // src/commands/agent/init.ts
-var __dirname2 = path14.dirname(fileURLToPath(import.meta.url));
-function resolveSourceDir(customSource) {
-  if (customSource) {
-    const resolved = path14.resolve(customSource);
-    return fs12.existsSync(resolved) ? resolved : null;
-  }
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var ASSET_CATEGORIES = ["agents", "skills"];
+function getBundledAssetsDir() {
   const candidates = [
-    path14.resolve(__dirname2, "..", "src/agent-assets"),
-    path14.resolve(__dirname2, "../..", "src/agent-assets")
+    resolve2(__dirname2, "..", "src", "agent-assets"),
+    resolve2(__dirname2, "..", "..", "src", "agent-assets"),
+    resolve2(__dirname2, "..", "..", "..", "src", "agent-assets")
   ];
-  return candidates.find((p5) => fs12.existsSync(p5)) ?? null;
+  return candidates.find((dir) => existsSync2(dir)) ?? null;
+}
+async function bootstrapAssetsIfNeeded(configDir, bundledDir) {
+  if (!bundledDir) return null;
+  const hasAssets = ASSET_CATEGORIES.some((cat) => existsSync2(join4(configDir, cat)));
+  if (hasAssets) return configDir;
+  for (const category of ASSET_CATEGORIES) {
+    const src = join4(bundledDir, category);
+    const dest = join4(configDir, category);
+    if (!existsSync2(src)) continue;
+    await mkdir2(dest, { recursive: true });
+    const entries = await readdir3(src, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      await cp2(join4(src, entry.name), join4(dest, entry.name), {
+        recursive: true,
+        force: false,
+        errorOnExist: false
+      });
+    }
+  }
+  return configDir;
+}
+async function resolveSourceDir(configDir, bundledDir) {
+  const config = configDir ?? getDefaultConfigDir();
+  const bundled = bundledDir === void 0 ? getBundledAssetsDir() : bundledDir;
+  const hasAssets = ASSET_CATEGORIES.some((cat) => existsSync2(join4(config, cat)));
+  if (hasAssets) return config;
+  const bootstrapped = await bootstrapAssetsIfNeeded(config, bundled);
+  if (bootstrapped) return bootstrapped;
+  return bundled;
 }
 function resolveAgentBaseDir(agentType, scope, cwd) {
   const agent = agents[agentType];
-  return scope === "global" && agent.globalConfigDir ? agent.globalConfigDir : path14.join(cwd, agent.configDir);
+  return scope === "global" && agent.globalConfigDir ? agent.globalConfigDir : join4(cwd, agent.configDir);
 }
 async function agentInitCommand(options) {
   try {
-    p4.intro(chalk15.blue("Initialize Agent Configuration"));
-    if (!process.stdin.isTTY && !options.all) {
-      p4.log.error("Not running in interactive terminal.");
-      p4.log.info("Use --all flag to install all assets without prompting.");
-      process.exit(1);
-    }
-    const sourceDir = resolveSourceDir(options.source);
+    p5.intro(chalk16.blue("Install Skills & Agents"));
+    const sourceDir = await resolveSourceDir();
     if (!sourceDir) {
-      p4.log.error("Source directory not found.");
-      if (options.source) {
-        p4.log.info(`Specified path: ${options.source}`);
-      } else {
-        p4.log.info("Bundled agent assets not found. Are you running from the package?");
-      }
+      p5.log.error("Agent assets not found.");
+      p5.log.info("Bundled agent assets not found. Are you running from the package?");
       process.exit(1);
     }
     const discovered = await discoverAllAssets(sourceDir);
     const totalAssets = discovered.agents.length + discovered.skills.length;
     if (totalAssets === 0) {
-      p4.log.warn(`No assets found in ${sourceDir}`);
+      p5.log.warn(`No assets found in ${sourceDir}`);
       process.exit(0);
     }
-    let selectedAgents;
-    if (options.agents) {
-      selectedAgents = options.agents;
-    } else if (options.all) {
-      selectedAgents = ["claude-code"];
-    } else {
-      const detected = await detectInstalledAgents();
-      const allAgents = getAllAgents();
-      const agentSelection = await p4.multiselect({
-        message: "Select target agents:",
-        options: allAgents.map((agent) => ({
-          value: agent.name,
-          label: agent.displayName,
-          hint: detected.includes(agent.name) ? "detected" : void 0
-        })),
-        initialValues: detected.length > 0 ? detected : ["claude-code"],
-        required: true
-      });
-      if (p4.isCancel(agentSelection)) {
-        p4.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      selectedAgents = agentSelection;
-    }
-    let scope = options.scope ?? "project";
-    if (!options.scope && !options.all) {
-      const supportsGlobal = selectedAgents.some((a) => agents[a].globalConfigDir !== void 0);
-      if (supportsGlobal) {
-        const scopeChoice = await p4.select({
-          message: "Installation scope:",
-          options: [
-            {
-              value: "project",
-              label: "Project",
-              hint: "Install to current directory"
-            },
-            {
-              value: "global",
-              label: "Global",
-              hint: "Install to home directory (available across projects)"
-            }
-          ],
-          initialValue: "project"
-        });
-        if (p4.isCancel(scopeChoice)) {
-          p4.cancel("Operation cancelled.");
-          process.exit(0);
-        }
-        scope = scopeChoice;
-      }
-    }
+    const selectedAgents = options.agents ?? ["claude-code"];
+    const scope = options.scope ?? "project";
     const mode = options.mode ?? "symlink";
+    const cwd = process.cwd();
     if (!options.force) {
-      const cwd2 = process.cwd();
       for (const agentType of selectedAgents) {
-        const agentDir = resolveAgentBaseDir(agentType, scope, cwd2);
-        if (fs12.existsSync(agentDir) && !options.all) {
-          const overwrite = await p4.confirm({
+        const agentDir = resolveAgentBaseDir(agentType, scope, cwd);
+        if (existsSync2(agentDir) && process.stdin.isTTY) {
+          const overwrite = await p5.confirm({
             message: `${agents[agentType].displayName} directory already exists at ${agentDir}. Overwrite?`,
             initialValue: false
           });
-          if (p4.isCancel(overwrite) || !overwrite) {
-            p4.cancel("Operation cancelled.");
+          if (p5.isCancel(overwrite) || !overwrite) {
+            p5.cancel("Operation cancelled.");
             process.exit(0);
           }
         }
       }
     }
-    let selectedCategories;
-    if (options.all) {
-      selectedCategories = ["agents", "skills"];
-    } else {
-      p4.note(
-        "Use \u2191/\u2193 to move, Space to select/deselect, A to toggle all, Enter to confirm.",
-        "Multi-select"
-      );
-      const selection = await p4.multiselect({
-        message: "What would you like to install?",
-        options: [
-          {
-            value: "agents",
-            label: "Agents",
-            hint: `${discovered.agents.length} specialized sub-agents`
-          },
-          {
-            value: "skills",
-            label: "Skills",
-            hint: `${discovered.skills.length} skill packages`
-          }
-        ],
-        initialValues: ["agents", "skills"],
-        required: false
-      });
-      if (p4.isCancel(selection)) {
-        p4.cancel("Operation cancelled.");
-        process.exit(0);
+    const allAssets = [...discovered.skills, ...discovered.agents];
+    const results = [];
+    for (const asset of allAssets) {
+      for (const agentType of selectedAgents) {
+        const result = await installAssetForAgent(asset, agentType, { scope, cwd, mode });
+        results.push({
+          asset,
+          agentType,
+          success: result.success,
+          symlinkFailed: result.symlinkFailed,
+          error: result.error
+        });
       }
-      selectedCategories = selection;
-      if (selectedCategories.length === 0) {
-        p4.cancel("No categories selected.");
-        process.exit(0);
+    }
+    for (const category of ASSET_CATEGORIES) {
+      const categoryResults = results.filter((r) => r.asset.category === category);
+      if (categoryResults.length === 0) continue;
+      const label = category.charAt(0).toUpperCase() + category.slice(1);
+      p5.log.step(chalk16.bold(label));
+      for (const entry of categoryResults) {
+        if (entry.success && entry.symlinkFailed) {
+          p5.log.warn(`  \u26A0 ${entry.asset.name} (symlink failed, copied instead)`);
+        } else if (entry.success) {
+          p5.log.success(`  \u2713 ${entry.asset.name}`);
+        } else {
+          p5.log.error(`  \u2717 ${entry.asset.name}: ${entry.error}`);
+        }
       }
     }
-    const assetsToInstall = [];
-    const assetCategories = ["agents", "skills"];
-    for (const category of assetCategories) {
-      if (!selectedCategories.includes(category)) continue;
-      const categoryAssets = discovered[category];
-      if (categoryAssets.length === 0) continue;
-      if (options.all) {
-        assetsToInstall.push(...categoryAssets);
-        continue;
+    const totalInstalled = results.filter((r) => r.success).length;
+    const totalFailed = results.filter((r) => !r.success).length;
+    const agentNames = selectedAgents.map((a) => agents[a].displayName).join(", ");
+    let message = `Installed ${totalInstalled} asset(s) to ${agentNames}`;
+    if (totalFailed > 0) {
+      message += chalk16.red(` (${totalFailed} failed)`);
+    }
+    message += chalk16.gray(`
+   Scope: ${scope} | Mode: ${mode}`);
+    p5.outro(message);
+  } catch (error) {
+    p5.log.error(`Error during agent init: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/agent/update.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+import { cp as cp3, readdir as readdir4, mkdir as mkdir3, rm as rm2, lstat as lstat2 } from "fs/promises";
+import chalk17 from "chalk";
+import * as p6 from "@clack/prompts";
+var ASSET_CATEGORIES2 = ["agents", "skills"];
+async function updateBundledAssets(configDir, bundledDir) {
+  const seeded = [];
+  const skipped = [];
+  for (const category of ASSET_CATEGORIES2) {
+    const bundledCategoryDir = join5(bundledDir, category);
+    const configCategoryDir = join5(configDir, category);
+    if (!existsSync3(bundledCategoryDir)) continue;
+    await mkdir3(configCategoryDir, { recursive: true });
+    const bundledEntries = await readdir4(bundledCategoryDir, { withFileTypes: true });
+    for (const entry of bundledEntries) {
+      if (!entry.isDirectory()) continue;
+      const src = join5(bundledCategoryDir, entry.name);
+      const dest = join5(configCategoryDir, entry.name);
+      await rm2(dest, { recursive: true, force: true });
+      await cp3(src, dest, { recursive: true });
+      seeded.push(`${category}/${entry.name}`);
+    }
+    if (existsSync3(configCategoryDir)) {
+      const configEntries = await readdir4(configCategoryDir, { withFileTypes: true });
+      const bundledNames = new Set(bundledEntries.filter((e) => e.isDirectory()).map((e) => e.name));
+      for (const entry of configEntries) {
+        if (entry.isDirectory() && !bundledNames.has(entry.name)) {
+          skipped.push(`${category}/${entry.name}`);
+        }
       }
-      const assetSelection = await p4.multiselect({
-        message: `Select ${category} to install:`,
-        options: categoryAssets.map((asset) => ({
-          value: asset.name,
-          label: asset.name,
-          hint: asset.description || void 0
-        })),
-        initialValues: categoryAssets.map((a) => a.name),
-        required: false
-      });
-      if (p4.isCancel(assetSelection)) {
-        p4.cancel("Operation cancelled.");
-        process.exit(0);
+    }
+  }
+  return { seeded, skipped };
+}
+async function detectInstallTargets(repoPaths) {
+  const targets = [];
+  for (const agent of getAllAgents()) {
+    for (const repoPath of repoPaths) {
+      const mode = await detectModeInDir(repoPath, agent.configDir);
+      if (mode) {
+        targets.push({ agentType: agent.name, scope: "project", mode, cwd: repoPath });
       }
-      const selectedNames = new Set(assetSelection);
-      assetsToInstall.push(...categoryAssets.filter((a) => selectedNames.has(a.name)));
     }
-    const cwd = process.cwd();
+    if (agent.globalConfigDir) {
+      const mode = await detectModeInBaseDir(agent.globalConfigDir);
+      if (mode) {
+        targets.push({ agentType: agent.name, scope: "global", mode, cwd: process.cwd() });
+      }
+    }
+  }
+  return targets;
+}
+async function detectModeInDir(repoPath, agentConfigDir) {
+  const baseDir = join5(repoPath, agentConfigDir);
+  return detectModeInBaseDir(baseDir);
+}
+async function detectModeInBaseDir(baseDir) {
+  let symlinkCount = 0;
+  let copyCount = 0;
+  for (const category of Object.values(CATEGORY_SUBDIRS)) {
+    const categoryDir = join5(baseDir, category);
+    if (!existsSync3(categoryDir)) continue;
+    try {
+      const entries = await readdir4(categoryDir);
+      for (const name of entries) {
+        const entryPath = join5(categoryDir, name);
+        try {
+          const stats = await lstat2(entryPath);
+          if (stats.isSymbolicLink()) {
+            symlinkCount++;
+          } else if (stats.isDirectory()) {
+            copyCount++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (symlinkCount === 0 && copyCount === 0) return null;
+  return symlinkCount >= copyCount ? "symlink" : "copy";
+}
+async function skillUpdateCommand(options) {
+  try {
+    p6.intro(chalk17.blue("Update Skills"));
+    const bundledDir = getBundledAssetsDir();
+    if (!bundledDir) {
+      p6.log.error("Bundled assets not found. Are you running from the package?");
+      process.exit(1);
+    }
+    const configDir = getDefaultConfigDir();
+    p6.log.step("Updating config directory from bundle...");
+    const seedResult = await updateBundledAssets(configDir, bundledDir);
+    for (const name of seedResult.seeded) {
+      p6.log.info(`  Updated: ${name}`);
+    }
+    if (seedResult.skipped.length > 0) {
+      p6.log.info(chalk17.gray(`  Preserved ${seedResult.skipped.length} custom asset(s)`));
+    }
+    const discovered = await discoverAllAssets(configDir);
+    const bundledAssetNames = new Set(seedResult.seeded.map((s2) => s2.split("/")[1]));
+    const bundledAssets = [
+      ...discovered.agents.filter((a) => bundledAssetNames.has(a.name)),
+      ...discovered.skills.filter((a) => bundledAssetNames.has(a.name))
+    ];
+    if (bundledAssets.length === 0) {
+      p6.log.warn("No assets to update.");
+      p6.outro("Done.");
+      return;
+    }
+    const repoPaths = [];
+    if (options.all) {
+      const config = loadConfigFile();
+      if (config.thoughts?.repoMappings) {
+        for (const repoPath of Object.keys(config.thoughts.repoMappings)) {
+          if (existsSync3(repoPath)) {
+            repoPaths.push(repoPath);
+          } else {
+            p6.log.warn(`Skipping (not found): ${repoPath}`);
+          }
+        }
+      }
+      const cwd = process.cwd();
+      if (!repoPaths.includes(cwd) && existsSync3(join5(cwd, ".git"))) {
+        repoPaths.push(cwd);
+      }
+    } else {
+      repoPaths.push(process.cwd());
+    }
+    p6.log.step("Detecting existing installations...");
+    const targets = await detectInstallTargets(repoPaths);
+    if (targets.length === 0) {
+      p6.log.warn("No existing installations detected. Run `thc skill install` first.");
+      p6.outro("Done.");
+      return;
+    }
+    for (const t of targets) {
+      const scopeLabel = t.scope === "global" ? "global" : t.cwd;
+      p6.log.info(chalk17.gray(`  ${agents[t.agentType].displayName}: ${scopeLabel} (${t.mode})`));
+    }
+    const s = p6.spinner();
+    s.start("Installing updated assets...");
     let totalInstalled = 0;
     let totalFailed = 0;
-    const s = p4.spinner();
-    s.start("Installing assets...");
-    for (const asset of assetsToInstall) {
-      for (const agentType of selectedAgents) {
-        const result = await installAssetForAgent(asset, agentType, { scope, cwd, mode });
+    for (const target of targets) {
+      for (const asset of bundledAssets) {
+        const result = await installAssetForAgent(asset, target.agentType, {
+          scope: target.scope,
+          cwd: target.cwd,
+          mode: target.mode
+        });
         if (result.success) {
           totalInstalled++;
-          if (result.symlinkFailed) {
-            p4.log.warn(
-              `${asset.name} \u2192 ${agents[agentType].displayName}: symlink failed, copied instead`
-            );
-          }
         } else {
           totalFailed++;
-          p4.log.warn(`Failed: ${asset.name} \u2192 ${agents[agentType].displayName}: ${result.error}`);
+          if (result.error) {
+            p6.log.warn(
+              `Failed: ${asset.name} \u2192 ${agents[target.agentType].displayName}: ${result.error}`
+            );
+          }
         }
       }
     }
-    s.stop("Installation complete.");
-    const agentNames = selectedAgents.map((a) => agents[a].displayName).join(", ");
-    let message = `Installed ${totalInstalled} asset(s) to ${agentNames}`;
+    s.stop("Update complete.");
+    const uniqueRepos = new Set(targets.filter((t) => t.scope === "project").map((t) => t.cwd));
+    const hasGlobal = targets.some((t) => t.scope === "global");
+    let message = `Updated ${totalInstalled} asset(s)`;
+    if (uniqueRepos.size > 0) {
+      message += ` in ${uniqueRepos.size} repo(s)`;
+    }
+    if (hasGlobal) {
+      message += ` + global`;
+    }
     if (totalFailed > 0) {
-      message += chalk15.red(` (${totalFailed} failed)`);
+      message += chalk17.red(` (${totalFailed} failed)`);
     }
-    message += chalk15.gray(`
-   Scope: ${scope} | Mode: ${mode}`);
-    p4.outro(message);
+    p6.outro(message);
   } catch (error) {
-    p4.log.error(`Error during agent init: ${error}`);
+    p6.log.error(`Error during skill update: ${error}`);
     process.exit(1);
   }
 }
 
 // src/commands/agent.ts
-function agentCommand(program) {
-  const agent = program.command("agent").description("Manage coding agent configuration");
-  agent.command("init").description("Initialize coding agent configuration in current directory").option("--target <agents...>", "Target agents (e.g., claude-code codebuddy)").option("-g, --global", "Install to global scope").option("--mode <mode>", "Installation mode: symlink or copy (default: symlink)").option("--source <path>", "Source directory for assets").option("--force", "Force overwrite of existing installations").option("--all", "Install all assets without prompting").action(async (options) => {
+function skillCommand(program) {
+  const skill = program.command("skill").description("Manage skill and agent asset installation");
+  skill.command("install").description("Install skills and agent configs to target agent directories").option("--target <agents...>", "Target agents (e.g., claude-code codebuddy)").option("-g, --global", "Install to global scope").option("--mode <mode>", "Installation mode: symlink or copy (default: symlink)").option("--force", "Force overwrite of existing installations").action(async (options) => {
     const agentTypes = options.target?.map((a) => {
       if (!isValidAgentType(a)) {
         console.error(`Unknown agent: ${a}`);
@@ -2756,22 +3190,23 @@ function agentCommand(program) {
       agents: agentTypes,
       scope: options.global ? "global" : void 0,
       mode,
-      source: options.source,
-      force: options.force,
-      all: options.all
+      force: options.force
     });
   });
+  skill.command("update").description("Update skills from package bundle and refresh installations").option("--all", "Update all registered repos (from config repoMappings)").action(async (options) => {
+    await skillUpdateCommand({ all: options.all });
+  });
 }
 
 // src/commands/metadata/metadata.ts
-import path15 from "path";
+import path16 from "path";
 function getGitInfo() {
   if (!isGitRepo()) {
     return null;
   }
   try {
     const repoRoot = getRepoRoot();
-    const repoName = path15.basename(repoRoot);
+    const repoName = path16.basename(repoRoot);
     const branch = getCurrentBranch();
     const commit = getCurrentCommit();
     return { repoRoot, repoName, branch, commit };
@@ -2825,8 +3260,8 @@ function metadataCommand(program) {
 
 // src/commands/worktree/add.ts
 import fs14 from "fs";
-import path17 from "path";
-import chalk16 from "chalk";
+import path18 from "path";
+import chalk18 from "chalk";
 
 // src/tmux.ts
 import { execFileSync as execFileSync3 } from "child_process";
@@ -2886,10 +3321,11 @@ function tmuxKillSession(sessionName) {
 
 // src/agent-config.ts
 import fs13 from "fs";
-import path16 from "path";
+import path17 from "path";
 function detectAgentConfigDirs(sourceDir) {
   const uniqueDirs = [...new Set(Object.values(agents).map((a) => a.configDir))];
-  return uniqueDirs.filter((dir) => fs13.existsSync(path16.join(sourceDir, dir)));
+  uniqueDirs.push(CANONICAL_DIR);
+  return uniqueDirs.filter((dir) => fs13.existsSync(path17.join(sourceDir, dir)));
 }
 function symlinkOrCopy(srcPath, destPath, linkTarget) {
   try {
@@ -2904,8 +3340,8 @@ function symlinkOrCopy(srcPath, destPath, linkTarget) {
 function copyDirWithSymlinkHandling(srcDir, destDir) {
   fs13.mkdirSync(destDir, { recursive: true });
   for (const entry of fs13.readdirSync(srcDir, { withFileTypes: true })) {
-    const srcPath = path16.join(srcDir, entry.name);
-    const destPath = path16.join(destDir, entry.name);
+    const srcPath = path17.join(srcDir, entry.name);
+    const destPath = path17.join(destDir, entry.name);
     if (entry.isSymbolicLink()) {
       symlinkOrCopy(srcPath, destPath, fs13.readlinkSync(srcPath));
     } else if (entry.isDirectory()) {
@@ -2921,7 +3357,7 @@ function copyAgentConfigDirs(options) {
   const skipped = [];
   for (const dirName of detectAgentConfigDirs(sourceDir)) {
     try {
-      copyDirWithSymlinkHandling(path16.join(sourceDir, dirName), path16.join(targetDir, dirName));
+      copyDirWithSymlinkHandling(path17.join(sourceDir, dirName), path17.join(targetDir, dirName));
       copied.push(dirName);
     } catch {
       skipped.push(dirName);
@@ -2935,21 +3371,21 @@ async function worktreeAddCommand(name, options) {
   try {
     validateWorktreeHandle(name);
     if (!isGitRepo()) {
-      console.error(chalk16.red("Error: not in a git repository"));
+      console.error(chalk18.red("Error: not in a git repository"));
       process.exit(1);
     }
     const mainRoot = getMainWorktreeRoot();
     const baseDir = getWorktreesBaseDir(mainRoot);
-    const worktreePath = options.path ? path17.resolve(options.path) : path17.join(baseDir, name);
+    const worktreePath = options.path ? path18.resolve(options.path) : path18.join(baseDir, name);
     const branch = options.detached ? "" : options.branch ?? name;
     const sessionName = sessionNameForHandle(name);
-    fs14.mkdirSync(path17.dirname(worktreePath), { recursive: true });
+    fs14.mkdirSync(path18.dirname(worktreePath), { recursive: true });
     const tmuxAvailable = isTmuxAvailable();
     if (tmuxAvailable) {
       const sessionCandidates = allSessionNamesForHandle(name);
       const existingSession = sessionCandidates.find((s) => tmuxHasSession(s));
       if (existingSession) {
-        console.error(chalk16.red(`Error: tmux session already exists: ${existingSession}`));
+        console.error(chalk18.red(`Error: tmux session already exists: ${existingSession}`));
         process.exit(1);
       }
     }
@@ -2993,14 +3429,14 @@ async function worktreeAddCommand(name, options) {
     if (tmuxAvailable) {
       tmuxNewSession(sessionName, worktreePath);
     } else {
-      console.log(chalk16.yellow("Warning: tmux not found, skipping session creation"));
+      console.log(chalk18.yellow("Warning: tmux not found, skipping session creation"));
     }
     const configResult = copyAgentConfigDirs({
       sourceDir: mainRoot,
       targetDir: worktreePath
     });
     if (configResult.copied.length > 0) {
-      console.log(chalk16.gray(`Copied config: ${configResult.copied.join(", ")}`));
+      console.log(chalk18.gray(`Copied config: ${configResult.copied.join(", ")}`));
     }
     if (options.thoughts !== false) {
       initializeWorktreeThoughts(mainRoot, worktreePath);
@@ -3029,27 +3465,27 @@ async function worktreeAddCommand(name, options) {
         true
       );
     }
-    console.log(chalk16.green("\n\u2713 Worktree created"));
-    console.log(chalk16.gray(`Path: ${worktreePath}`));
+    console.log(chalk18.green("\n\u2713 Worktree created"));
+    console.log(chalk18.gray(`Path: ${worktreePath}`));
     if (tmuxAvailable) {
-      console.log(chalk16.gray(`Tmux session: ${sessionName}`));
-      console.log(chalk16.gray(`Attach: tmux attach -t ${sessionName}`));
+      console.log(chalk18.gray(`Tmux session: ${sessionName}`));
+      console.log(chalk18.gray(`Attach: tmux attach -t ${sessionName}`));
     }
   } catch (error) {
-    console.error(chalk16.red(`Error: ${error.message}`));
+    console.error(chalk18.red(`Error: ${error.message}`));
     process.exit(1);
   }
 }
 function initializeWorktreeThoughts(mainRoot, worktreePath) {
   const config = loadThoughtsConfig({});
   if (!config) {
-    console.log(chalk16.yellow("Thoughts not configured globally, skipping"));
+    console.log(chalk18.yellow("Thoughts not configured globally, skipping"));
     return;
   }
   const mainRepoMapping = config.repoMappings[mainRoot];
   const mappedName = getRepoNameFromMapping(mainRepoMapping);
   if (!mappedName) {
-    console.log(chalk16.yellow("Main repo not configured for thoughts, skipping"));
+    console.log(chalk18.yellow("Main repo not configured for thoughts, skipping"));
     return;
   }
   config.repoMappings[worktreePath] = mainRepoMapping;
@@ -3064,42 +3500,42 @@ function initializeWorktreeThoughts(mainRoot, worktreePath) {
     createSearchable: true,
     setupHooks: true
   });
-  console.log(chalk16.gray("Thoughts initialized"));
+  console.log(chalk18.gray("Thoughts initialized"));
   if (result.hooksUpdated.length > 0) {
-    console.log(chalk16.gray(`Updated git hooks: ${result.hooksUpdated.join(", ")}`));
+    console.log(chalk18.gray(`Updated git hooks: ${result.hooksUpdated.join(", ")}`));
   }
   if (pullThoughtsFromRemote(profileConfig.thoughtsRepo)) {
-    console.log(chalk16.gray("Pulled latest thoughts from remote"));
+    console.log(chalk18.gray("Pulled latest thoughts from remote"));
   }
 }
 
 // src/commands/worktree/list.ts
-import path18 from "path";
-import chalk17 from "chalk";
+import path19 from "path";
+import chalk19 from "chalk";
 async function worktreeListCommand(options) {
   try {
     if (!isGitRepo()) {
-      console.error(chalk17.red("Error: not in a git repository"));
+      console.error(chalk19.red("Error: not in a git repository"));
       process.exit(1);
     }
     const mainRoot = getMainWorktreeRoot();
-    const baseDir = path18.resolve(getWorktreesBaseDir(mainRoot));
-    const cwd = path18.resolve(process.cwd());
+    const baseDir = path19.resolve(getWorktreesBaseDir(mainRoot));
+    const cwd = path19.resolve(process.cwd());
     const entries = parseWorktreeListPorcelain(
       runGitCommand(["worktree", "list", "--porcelain"], { cwd: mainRoot })
     );
     const sessions = new Set(listTmuxSessions());
     const filtered = options.all ? entries : entries.filter((e) => {
-      const p5 = path18.resolve(e.worktreePath);
-      return p5 === path18.resolve(mainRoot) || p5.startsWith(baseDir + path18.sep);
+      const p7 = path19.resolve(e.worktreePath);
+      return p7 === path19.resolve(mainRoot) || p7.startsWith(baseDir + path19.sep);
     });
     if (filtered.length === 0) {
-      console.log(chalk17.gray("No worktrees found."));
+      console.log(chalk19.gray("No worktrees found."));
       return;
     }
     const rows = filtered.map((e) => {
-      const name = path18.basename(e.worktreePath);
-      const isCurrent = path18.resolve(e.worktreePath) === cwd;
+      const name = path19.basename(e.worktreePath);
+      const isCurrent = path19.resolve(e.worktreePath) === cwd;
       return {
         name: isCurrent ? `* ${name}` : `  ${name}`,
         branch: e.branch,
@@ -3114,24 +3550,24 @@ async function worktreeListCommand(options) {
       tmux: Math.max("TMUX".length, ...rows.map((r) => r.tmux.length))
     };
     const header = `${"  NAME".padEnd(colWidths.name)}  ${"BRANCH".padEnd(colWidths.branch)}  ${"TMUX".padEnd(colWidths.tmux)}  PATH`;
-    console.log(chalk17.blue(header));
+    console.log(chalk19.blue(header));
     for (const row of rows) {
       const line = `${row.name.padEnd(colWidths.name)}  ${row.branch.padEnd(colWidths.branch)}  ${row.tmux.padEnd(colWidths.tmux)}  ${row.path}`;
-      console.log(row.isCurrent ? chalk17.green(line) : line);
+      console.log(row.isCurrent ? chalk19.green(line) : line);
     }
   } catch (error) {
-    console.error(chalk17.red(`Error: ${error.message}`));
+    console.error(chalk19.red(`Error: ${error.message}`));
     process.exit(1);
   }
 }
 
 // src/commands/worktree/merge.ts
-import path20 from "path";
-import chalk19 from "chalk";
+import path21 from "path";
+import chalk21 from "chalk";
 
 // src/commands/worktree/utils.ts
-import path19 from "path";
-import chalk18 from "chalk";
+import path20 from "path";
+import chalk20 from "chalk";
 function cleanupWorktreeThoughts(wtPath, options = {}) {
   const config = loadThoughtsConfig({});
   if (!config || !config.repoMappings[wtPath]) {
@@ -3139,7 +3575,7 @@ function cleanupWorktreeThoughts(wtPath, options = {}) {
   }
   try {
     if (options.verbose) {
-      console.log(chalk18.gray("Cleaning up thoughts directory..."));
+      console.log(chalk20.gray("Cleaning up thoughts directory..."));
     }
     const result = cleanupThoughtsDirectory({
       repoPath: wtPath,
@@ -3151,16 +3587,16 @@ function cleanupWorktreeThoughts(wtPath, options = {}) {
       saveThoughtsConfig(config, {});
     }
     if (result.thoughtsRemoved && options.verbose) {
-      console.log(chalk18.gray("\u2713 Thoughts directory cleaned up"));
+      console.log(chalk20.gray("\u2713 Thoughts directory cleaned up"));
     }
   } catch (error) {
     if (options.verbose) {
-      console.log(chalk18.yellow(`Warning: Could not clean up thoughts: ${error.message}`));
+      console.log(chalk20.yellow(`Warning: Could not clean up thoughts: ${error.message}`));
     }
   }
 }
 function cleanupWorktreeTmuxSession(wtPath) {
-  const handle = path19.basename(wtPath);
+  const handle = path20.basename(wtPath);
   const sessionNames = allSessionNamesForHandle(handle);
   for (const s of sessionNames) {
     tmuxKillSession(s);
@@ -3194,27 +3630,27 @@ function deleteWorktreeBranch(branch, mainRoot, options = {}) {
 async function worktreeMergeCommand(name, options) {
   try {
     if (!isGitRepo()) {
-      console.error(chalk19.red("Error: not in a git repository"));
+      console.error(chalk21.red("Error: not in a git repository"));
       process.exit(1);
     }
     const mainRoot = getMainWorktreeRoot();
     const wtEntry = findWorktree(name, mainRoot);
-    const wtPath = path20.resolve(wtEntry.worktreePath);
-    if (wtPath === path20.resolve(mainRoot)) {
-      console.error(chalk19.red("Error: refusing to merge/remove the main worktree"));
+    const wtPath = path21.resolve(wtEntry.worktreePath);
+    if (wtPath === path21.resolve(mainRoot)) {
+      console.error(chalk21.red("Error: refusing to merge/remove the main worktree"));
       process.exit(1);
     }
     if (wtEntry.detached || wtEntry.branch === "(detached)") {
-      console.error(chalk19.red("Error: cannot merge a detached worktree"));
+      console.error(chalk21.red("Error: cannot merge a detached worktree"));
       process.exit(1);
     }
     const targetBranch = options.into ?? runGitCommand(["branch", "--show-current"], { cwd: mainRoot });
     if (!targetBranch) {
-      console.error(chalk19.red("Error: could not determine target branch. Use --into <branch>."));
+      console.error(chalk21.red("Error: could not determine target branch. Use --into <branch>."));
       process.exit(1);
     }
     if (targetBranch === wtEntry.branch) {
-      console.error(chalk19.red("Error: source and target branch are the same"));
+      console.error(chalk21.red("Error: source and target branch are the same"));
       process.exit(1);
     }
     const hooksConfig = loadHooksConfig(mainRoot);
@@ -3245,13 +3681,13 @@ async function worktreeMergeCommand(name, options) {
     cleanupWorktreeThoughts(wtPath, { force: options.force, verbose: true });
     if (!options.force && hasUncommittedChanges(wtEntry.worktreePath)) {
       console.error(
-        chalk19.red("Error: worktree has uncommitted changes. Commit/stash first or use --force.")
+        chalk21.red("Error: worktree has uncommitted changes. Commit/stash first or use --force.")
       );
       process.exit(1);
     }
-    console.log(chalk19.blue(`Rebasing ${wtEntry.branch} onto ${targetBranch}...`));
+    console.log(chalk21.blue(`Rebasing ${wtEntry.branch} onto ${targetBranch}...`));
     runGitCommandOrThrow(["rebase", targetBranch], { cwd: wtEntry.worktreePath });
-    console.log(chalk19.blue(`Fast-forward merging into ${targetBranch}...`));
+    console.log(chalk21.blue(`Fast-forward merging into ${targetBranch}...`));
     runGitCommandOrThrow(["switch", targetBranch], { cwd: mainRoot });
     runGitCommandOrThrow(["merge", "--ff-only", wtEntry.branch], { cwd: mainRoot });
     if (!options.keepSession) {
@@ -3293,35 +3729,35 @@ async function worktreeMergeCommand(name, options) {
         true
       );
     }
-    console.log(chalk19.green("\u2713 Merged and cleaned up"));
+    console.log(chalk21.green("\u2713 Merged and cleaned up"));
   } catch (error) {
-    console.error(chalk19.red(`Error: ${error.message}`));
+    console.error(chalk21.red(`Error: ${error.message}`));
     process.exit(1);
   }
 }
 
 // src/commands/worktree/remove.ts
-import path21 from "path";
-import chalk20 from "chalk";
+import path22 from "path";
+import chalk22 from "chalk";
 async function worktreeRemoveCommand(name, options) {
   try {
     if (!isGitRepo()) {
-      console.error(chalk20.red("Error: not in a git repository"));
+      console.error(chalk22.red("Error: not in a git repository"));
       process.exit(1);
     }
     const mainRoot = getMainWorktreeRoot();
     const wtEntry = findWorktree(name, mainRoot);
-    const wtPath = path21.resolve(wtEntry.worktreePath);
+    const wtPath = path22.resolve(wtEntry.worktreePath);
     const hasBranch = !wtEntry.detached && wtEntry.branch !== "(detached)";
-    if (wtPath === path21.resolve(mainRoot)) {
-      console.error(chalk20.red("Error: refusing to remove the main worktree"));
+    if (wtPath === path22.resolve(mainRoot)) {
+      console.error(chalk22.red("Error: refusing to remove the main worktree"));
       process.exit(1);
     }
     if (!options.force && hasBranch) {
       const defaultBranch = getDefaultBranch(mainRoot);
       if (hasUnmergedCommits(wtEntry.branch, defaultBranch, mainRoot)) {
         console.error(
-          chalk20.red(
+          chalk22.red(
             `Error: branch '${wtEntry.branch}' has commits not merged into '${defaultBranch}'. Merge first or use --force to discard.`
           )
         );
@@ -3354,19 +3790,19 @@ async function worktreeRemoveCommand(name, options) {
     cleanupWorktreeThoughts(wtPath, { force: options.force, verbose: true });
     if (!options.force && hasUncommittedChanges(wtEntry.worktreePath)) {
       console.error(
-        chalk20.red("Error: worktree has uncommitted changes. Commit/stash first or use --force.")
+        chalk22.red("Error: worktree has uncommitted changes. Commit/stash first or use --force.")
       );
       process.exit(1);
     }
     cleanupWorktreeTmuxSession(wtPath);
-    console.log(chalk20.gray("Removing git worktree..."));
+    console.log(chalk22.gray("Removing git worktree..."));
     removeGitWorktree(wtPath, mainRoot, { force: options.force });
     if (hasBranch) {
-      console.log(chalk20.gray(`Deleting branch '${wtEntry.branch}'...`));
+      console.log(chalk22.gray(`Deleting branch '${wtEntry.branch}'...`));
       try {
         deleteWorktreeBranch(wtEntry.branch, mainRoot, { force: options.force });
       } catch (error) {
-        console.log(chalk20.yellow(`Warning: ${error.message}`));
+        console.log(chalk22.yellow(`Warning: ${error.message}`));
       }
     }
     const postHooks = getHooksForEvent(hooksConfig, "PostWorktreeRemove");
@@ -3391,9 +3827,9 @@ async function worktreeRemoveCommand(name, options) {
         true
       );
     }
-    console.log(chalk20.green("\u2713 Worktree removed"));
+    console.log(chalk22.green("\u2713 Worktree removed"));
   } catch (error) {
-    console.error(chalk20.red(`Error: ${error.message}`));
+    console.error(chalk22.red(`Error: ${error.message}`));
     process.exit(1);
   }
 }
@@ -3416,27 +3852,27 @@ function worktreeCommand(program) {
 
 // src/commands/hooks/init.ts
 import fs15 from "fs";
-import path22 from "path";
-import chalk21 from "chalk";
+import path23 from "path";
+import chalk23 from "chalk";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname2(__filename2);
+var __dirname3 = dirname3(__filename2);
 async function hooksInitCommand() {
   try {
     const repoPath = process.cwd();
-    const configDir = path22.join(repoPath, HOOKS_CONFIG_DIR);
-    const configPath = path22.join(repoPath, HOOKS_CONFIG_FILE);
+    const configDir = path23.join(repoPath, HOOKS_CONFIG_DIR);
+    const configPath = path23.join(repoPath, HOOKS_CONFIG_FILE);
     if (fs15.existsSync(configPath)) {
-      console.log(chalk21.yellow(`${HOOKS_CONFIG_FILE} already exists.`));
-      console.log(chalk21.gray(`Edit the file directly: ${configPath}`));
+      console.log(chalk23.yellow(`${HOOKS_CONFIG_FILE} already exists.`));
+      console.log(chalk23.gray(`Edit the file directly: ${configPath}`));
       return;
     }
     const possiblePaths = [
       // When running from built dist: one level up from dist/
-      path22.resolve(__dirname3, "..", ".thought-cabinet/hooks.example.json"),
+      path23.resolve(__dirname3, "..", ".thought-cabinet/hooks.example.json"),
       // When installed via npm: one level up from dist/
-      path22.resolve(__dirname3, "../..", ".thought-cabinet/hooks.example.json")
+      path23.resolve(__dirname3, "../..", ".thought-cabinet/hooks.example.json")
     ];
     let examplePath = null;
     for (const candidatePath of possiblePaths) {
@@ -3446,16 +3882,16 @@ async function hooksInitCommand() {
       }
     }
     if (!examplePath) {
-      console.error(chalk21.red("Error: hooks.example.json not found in expected locations"));
-      console.log(chalk21.gray("Searched paths:"));
-      possiblePaths.forEach((p5) => console.log(chalk21.gray(`  - ${p5}`)));
+      console.error(chalk23.red("Error: hooks.example.json not found in expected locations"));
+      console.log(chalk23.gray("Searched paths:"));
+      possiblePaths.forEach((p7) => console.log(chalk23.gray(`  - ${p7}`)));
       process.exit(1);
     }
     fs15.mkdirSync(configDir, { recursive: true });
     fs15.copyFileSync(examplePath, configPath);
-    console.log(chalk21.green(`Created ${HOOKS_CONFIG_FILE}`));
+    console.log(chalk23.green(`Created ${HOOKS_CONFIG_FILE}`));
   } catch (error) {
-    console.error(chalk21.red(`Error during hooks init: ${error}`));
+    console.error(chalk23.red(`Error during hooks init: ${error}`));
     process.exit(1);
   }
 }
@@ -3483,7 +3919,7 @@ function completionCommand(program) {
 import tabtab from "tabtab";
 
 // src/completion/providers.ts
-import path23 from "path";
+import path24 from "path";
 function getProfileNames() {
   try {
     const config = loadConfigFile();
@@ -3505,9 +3941,9 @@ function getWorktreeNames() {
     const output = runGitCommand(["worktree", "list", "--porcelain"]);
     const entries = parseWorktreeListPorcelain(output);
     return entries.filter((e) => {
-      const p5 = path23.resolve(e.worktreePath);
-      return p5.startsWith(baseDir + path23.sep);
-    }).map((e) => path23.basename(e.worktreePath));
+      const p7 = path24.resolve(e.worktreePath);
+      return p7.startsWith(baseDir + path24.sep);
+    }).map((e) => path24.basename(e.worktreePath));
   } catch {
     return [];
   }
@@ -3535,9 +3971,10 @@ var TOP_LEVEL_COMMANDS = [
   "status",
   "config",
   "prune",
+  "migrate",
   "profile",
   "worktree",
-  "agent",
+  "skill",
   "metadata",
   "hooks",
   "completion"
@@ -3545,7 +3982,7 @@ var TOP_LEVEL_COMMANDS = [
 var SUBCOMMANDS = {
   profile: ["create", "list", "show", "delete"],
   worktree: ["add", "list", "merge", "remove"],
-  agent: ["init"],
+  skill: ["install", "update"],
   hooks: ["init"],
   completion: ["install", "uninstall"]
 };
@@ -3556,6 +3993,7 @@ var OPTIONS = {
   status: ["--config-file", "--fetch"],
   config: ["--edit", "--json", "--config-file"],
   prune: ["--apply", "--config-file"],
+  migrate: ["--dry-run", "--config-file"],
   "profile create": ["--repo", "--repos-dir", "--global-dir", "--config-file"],
   "profile list": ["--json", "--config-file"],
   "profile show": ["--json", "--config-file"],
@@ -3564,7 +4002,8 @@ var OPTIONS = {
   "worktree list": ["--all"],
   "worktree merge": ["--into", "--force", "--keep-session", "--keep-worktree", "--keep-branch"],
   "worktree remove": ["--force"],
-  "agent init": ["--force", "--all", "--target", "--global", "--mode", "--source"]
+  "skill install": ["--force", "--target", "--global", "--mode"],
+  "skill update": ["--all"]
 };
 var DYNAMIC_ARGS = {
   "profile show": getProfileNames,
@@ -3649,7 +4088,7 @@ async function main() {
     "Thought Cabinet (thc) \u2014 CLI for structured AI coding workflows with filesystem-based memory and context management."
   ).version(version);
   thoughtsCommand(program);
-  agentCommand(program);
+  skillCommand(program);
   metadataCommand(program);
   worktreeCommand(program);
   hooksCommand(program);