thought-cabinet 0.0.3 → 0.1.0

package/dist/index.js

@@ -4,10 +4,10 @@
 import { Command } from "commander";
 
 // src/commands/thoughts/init.ts
-import fs4 from "fs";
-import path6 from "path";
-import { execSync as execSync2 } from "child_process";
-import chalk2 from "chalk";
+import fs7 from "fs";
+import path10 from "path";
+import { execSync as execSync4 } from "child_process";
+import chalk5 from "chalk";
 import * as p from "@clack/prompts";
 
 // src/config.ts
@@ -80,42 +80,147 @@ function saveThoughtsConfig(thoughtsConfig, options = {}) {
 }
 
 // src/commands/thoughts/utils/paths.ts
-import path2 from "path";
+import path3 from "path";
 import os from "os";
+
+// src/git.ts
+import { execFileSync } from "child_process";
+import path2 from "path";
+function runGitCommand(args, opts = {}) {
+  return execFileSync("git", args, {
+    cwd: opts.cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function runGitCommandOrThrow(args, opts = {}) {
+  execFileSync("git", args, {
+    cwd: opts.cwd,
+    stdio: "inherit"
+  });
+}
+function isGitRepo(cwd) {
+  try {
+    runGitCommand(["rev-parse", "--git-dir"], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getMainRepoPath() {
+  try {
+    const gitCommonDir = runGitCommand(["rev-parse", "--git-common-dir"]);
+    const gitDir = runGitCommand(["rev-parse", "--git-dir"]);
+    if (gitCommonDir !== gitDir && gitCommonDir !== ".git") {
+      const mainRepoPath = path2.dirname(path2.resolve(gitCommonDir));
+      return mainRepoPath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function validateWorktreeHandle(name) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
+    throw new Error(
+      `Invalid worktree name '${name}'. Use only [A-Za-z0-9._-] and start with a letter/number.`
+    );
+  }
+}
+function parseWorktreeListPorcelain(output) {
+  const blocks = output.trim().length === 0 ? [] : output.trim().split(/\n\n+/);
+  const out = [];
+  for (const block of blocks) {
+    let worktreePath = "";
+    let branch = "";
+    let detached = false;
+    for (const line of block.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        worktreePath = line.slice("worktree ".length).trim();
+      } else if (line.startsWith("branch refs/heads/")) {
+        branch = line.slice("branch refs/heads/".length).trim();
+      } else if (line.trim() === "detached") {
+        detached = true;
+        branch = "(detached)";
+      }
+    }
+    if (worktreePath && branch) {
+      out.push({ worktreePath, branch, detached });
+    }
+  }
+  return out;
+}
+function getMainWorktreeRoot(cwd) {
+  const list = runGitCommand(["worktree", "list", "--porcelain"], { cwd });
+  const entries = parseWorktreeListPorcelain(list);
+  if (entries.length === 0) {
+    throw new Error("No git worktrees found");
+  }
+  return entries[0].worktreePath;
+}
+function getWorktreesBaseDir(mainWorktreeRoot) {
+  const repoName = path2.basename(mainWorktreeRoot);
+  const parent = path2.dirname(mainWorktreeRoot);
+  return path2.join(parent, `${repoName}__worktrees`);
+}
+function findWorktree(nameOrBranch, cwd) {
+  const list = runGitCommand(["worktree", "list", "--porcelain"], { cwd });
+  const entries = parseWorktreeListPorcelain(list);
+  for (const e of entries) {
+    if (path2.basename(e.worktreePath) === nameOrBranch) {
+      return e;
+    }
+  }
+  for (const e of entries) {
+    if (e.branch === nameOrBranch) {
+      return e;
+    }
+  }
+  throw new Error(`Worktree not found: ${nameOrBranch}`);
+}
+function hasUncommittedChanges(repoPath) {
+  const status = runGitCommand(["status", "--porcelain"], { cwd: repoPath });
+  return status.trim().length > 0;
+}
+function setBranchBase(branch, base, cwd) {
+  runGitCommandOrThrow(["config", "--local", `branch.${branch}.thc-base`, base], { cwd });
+}
+
+// src/commands/thoughts/utils/paths.ts
 function getDefaultThoughtsRepo() {
-  return path2.join(os.homedir(), "thoughts");
+  return path3.join(os.homedir(), "thoughts");
 }
 function expandPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return path2.join(os.homedir(), filePath.slice(2));
+    return path3.join(os.homedir(), filePath.slice(2));
   }
-  return path2.resolve(filePath);
+  return path3.resolve(filePath);
 }
 function getCurrentRepoPath() {
   return process.cwd();
 }
 function getRepoNameFromPath(repoPath) {
-  const parts = repoPath.split(path2.sep);
+  const parts = repoPath.split(path3.sep);
   return parts[parts.length - 1] || "unnamed_repo";
 }
 function getRepoThoughtsPath(thoughtsRepoOrConfig, reposDirOrRepoName, repoName) {
   if (typeof thoughtsRepoOrConfig === "string") {
-    return path2.join(expandPath(thoughtsRepoOrConfig), reposDirOrRepoName, repoName);
+    return path3.join(expandPath(thoughtsRepoOrConfig), reposDirOrRepoName, repoName);
   }
   const config = thoughtsRepoOrConfig;
-  return path2.join(expandPath(config.thoughtsRepo), config.reposDir, reposDirOrRepoName);
+  return path3.join(expandPath(config.thoughtsRepo), config.reposDir, reposDirOrRepoName);
 }
 function getGlobalThoughtsPath(thoughtsRepoOrConfig, globalDir) {
   if (typeof thoughtsRepoOrConfig === "string") {
-    return path2.join(expandPath(thoughtsRepoOrConfig), globalDir);
+    return path3.join(expandPath(thoughtsRepoOrConfig), globalDir);
   }
   const config = thoughtsRepoOrConfig;
-  return path2.join(expandPath(config.thoughtsRepo), config.globalDir);
+  return path3.join(expandPath(config.thoughtsRepo), config.globalDir);
 }
 
 // src/commands/thoughts/utils/repository.ts
 import fs2 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { execSync } from "child_process";
 
 // src/templates/gitignore.ts
@@ -158,7 +263,7 @@ This directory contains thoughts and notes that apply across all repositories.
 }
 
 // src/templates/agentMd.ts
-import path3 from "path";
+import path4 from "path";
 import os2 from "os";
 function generateAgentMd({
   thoughtsRepo,
@@ -167,8 +272,8 @@ function generateAgentMd({
   user,
   productName
 }) {
-  const reposPath = path3.join(thoughtsRepo, reposDir, repoName).replace(os2.homedir(), "~");
-  const globalPath = path3.join(thoughtsRepo, "global").replace(os2.homedir(), "~");
+  const reposPath = path4.join(thoughtsRepo, reposDir, repoName).replace(os2.homedir(), "~");
+  const globalPath = path4.join(thoughtsRepo, "global").replace(os2.homedir(), "~");
   return `# Thoughts Directory Structure
 
 This directory contains developer thoughts and notes for the ${repoName} repository.
@@ -288,20 +393,20 @@ function ensureThoughtsRepoExists(configOrThoughtsRepo, reposDir, globalDir) {
   if (!fs2.existsSync(expandedRepo)) {
     fs2.mkdirSync(expandedRepo, { recursive: true });
   }
-  const expandedRepos = path4.join(expandedRepo, effectiveReposDir);
-  const expandedGlobal = path4.join(expandedRepo, effectiveGlobalDir);
+  const expandedRepos = path5.join(expandedRepo, effectiveReposDir);
+  const expandedGlobal = path5.join(expandedRepo, effectiveGlobalDir);
   if (!fs2.existsSync(expandedRepos)) {
     fs2.mkdirSync(expandedRepos, { recursive: true });
   }
   if (!fs2.existsSync(expandedGlobal)) {
     fs2.mkdirSync(expandedGlobal, { recursive: true });
   }
-  const gitPath = path4.join(expandedRepo, ".git");
-  const isGitRepo = fs2.existsSync(gitPath) && (fs2.statSync(gitPath).isDirectory() || fs2.statSync(gitPath).isFile());
-  if (!isGitRepo) {
+  const gitPath = path5.join(expandedRepo, ".git");
+  const isGitRepo2 = fs2.existsSync(gitPath) && (fs2.statSync(gitPath).isDirectory() || fs2.statSync(gitPath).isFile());
+  if (!isGitRepo2) {
     execSync("git init", { cwd: expandedRepo });
     const gitignore = generateGitignore();
-    fs2.writeFileSync(path4.join(expandedRepo, ".gitignore"), gitignore);
+    fs2.writeFileSync(path5.join(expandedRepo, ".gitignore"), gitignore);
     execSync("git add .gitignore", { cwd: expandedRepo });
     execSync('git commit -m "Initial thoughts repository setup"', { cwd: expandedRepo });
   }
@@ -328,11 +433,11 @@ function createThoughtsDirectoryStructure(configOrThoughtsRepo, reposDirOrRepoNa
     resolvedConfig.reposDir,
     effectiveRepoName
   );
-  const repoUserPath = path4.join(repoThoughtsPath, effectiveUser);
-  const repoSharedPath = path4.join(repoThoughtsPath, "shared");
+  const repoUserPath = path5.join(repoThoughtsPath, effectiveUser);
+  const repoSharedPath = path5.join(repoThoughtsPath, "shared");
   const globalPath = getGlobalThoughtsPath(resolvedConfig.thoughtsRepo, resolvedConfig.globalDir);
-  const globalUserPath = path4.join(globalPath, effectiveUser);
-  const globalSharedPath = path4.join(globalPath, "shared");
+  const globalUserPath = path5.join(globalPath, effectiveUser);
+  const globalSharedPath = path5.join(globalPath, "shared");
   for (const dir of [repoUserPath, repoSharedPath, globalUserPath, globalSharedPath]) {
     if (!fs2.existsSync(dir)) {
       fs2.mkdirSync(dir, { recursive: true });
@@ -345,17 +450,17 @@ function createThoughtsDirectoryStructure(configOrThoughtsRepo, reposDirOrRepoNa
   const globalReadme = generateGlobalReadme({
     user: effectiveUser
   });
-  if (!fs2.existsSync(path4.join(repoThoughtsPath, "README.md"))) {
-    fs2.writeFileSync(path4.join(repoThoughtsPath, "README.md"), repoReadme);
+  if (!fs2.existsSync(path5.join(repoThoughtsPath, "README.md"))) {
+    fs2.writeFileSync(path5.join(repoThoughtsPath, "README.md"), repoReadme);
   }
-  if (!fs2.existsSync(path4.join(globalPath, "README.md"))) {
-    fs2.writeFileSync(path4.join(globalPath, "README.md"), globalReadme);
+  if (!fs2.existsSync(path5.join(globalPath, "README.md"))) {
+    fs2.writeFileSync(path5.join(globalPath, "README.md"), globalReadme);
   }
 }
 
 // src/commands/thoughts/utils/symlinks.ts
 import fs3 from "fs";
-import path5 from "path";
+import path6 from "path";
 function updateSymlinksForNewUsers(currentRepoPath, configOrThoughtsRepo, reposDirOrRepoName, repoNameOrCurrentUser, currentUser) {
   let resolvedConfig;
   let effectiveRepoName;
@@ -372,7 +477,7 @@ function updateSymlinksForNewUsers(currentRepoPath, configOrThoughtsRepo, reposD
     effectiveRepoName = reposDirOrRepoName;
     effectiveUser = repoNameOrCurrentUser;
   }
-  const thoughtsDir = path5.join(currentRepoPath, "thoughts");
+  const thoughtsDir = path6.join(currentRepoPath, "thoughts");
   const repoThoughtsPath = getRepoThoughtsPath(
     resolvedConfig.thoughtsRepo,
     resolvedConfig.reposDir,
@@ -385,8 +490,8 @@ function updateSymlinksForNewUsers(currentRepoPath, configOrThoughtsRepo, reposD
   const entries = fs3.readdirSync(repoThoughtsPath, { withFileTypes: true });
   const userDirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "shared" && !entry.name.startsWith(".")).map((entry) => entry.name);
   for (const userName of userDirs) {
-    const symlinkPath = path5.join(thoughtsDir, userName);
-    const targetPath = path5.join(repoThoughtsPath, userName);
+    const symlinkPath = path6.join(thoughtsDir, userName);
+    const targetPath = path6.join(repoThoughtsPath, userName);
     if (!fs3.existsSync(symlinkPath) && userName !== effectiveUser) {
       try {
         fs3.symlinkSync(targetPath, symlinkPath, "dir");
@@ -398,6 +503,12 @@ function updateSymlinksForNewUsers(currentRepoPath, configOrThoughtsRepo, reposD
   return addedSymlinks;
 }
 
+// src/commands/thoughts/utils/cleanup.ts
+import fs4 from "fs";
+import path7 from "path";
+import { execSync as execSync2 } from "child_process";
+import chalk2 from "chalk";
+
 // src/commands/thoughts/profile/utils.ts
 function resolveProfileForRepo(config, repoPath) {
   const mapping = config.repoMappings[repoPath];
@@ -451,104 +562,436 @@ function sanitizeProfileName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 
-// src/commands/thoughts/init.ts
-function sanitizeDirectoryName(name) {
-  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function checkExistingSetup(config) {
-  const thoughtsDir = path6.join(process.cwd(), "thoughts");
+// src/commands/thoughts/utils/cleanup.ts
+function cleanupThoughtsDirectory({
+  repoPath,
+  config,
+  force = false,
+  verbose = true
+}) {
+  const thoughtsDir = path7.join(repoPath, "thoughts");
+  const result = {
+    thoughtsRemoved: false,
+    configRemoved: false
+  };
   if (!fs4.existsSync(thoughtsDir)) {
-    return { exists: false, isValid: false };
+    return result;
   }
-  if (!fs4.lstatSync(thoughtsDir).isDirectory()) {
-    return { exists: true, isValid: false, message: "thoughts exists but is not a directory" };
+  const mapping = config.repoMappings[repoPath];
+  const mappedName = getRepoNameFromMapping(mapping);
+  const profileName = getProfileNameFromMapping(mapping);
+  result.mappedName = mappedName;
+  result.profileName = profileName;
+  if (!mappedName && !force) {
+    return result;
   }
-  if (!config) {
-    return {
-      exists: true,
-      isValid: false,
-      message: "thoughts directory exists but configuration is missing"
-    };
+  const searchableDir = path7.join(thoughtsDir, "searchable");
+  if (fs4.existsSync(searchableDir)) {
+    if (verbose) {
+      console.log(chalk2.gray("Removing searchable directory..."));
+    }
+    try {
+      execSync2(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
+    } catch {
+    }
+    fs4.rmSync(searchableDir, { recursive: true, force: true });
   }
-  const userPath = path6.join(thoughtsDir, config.user);
-  const sharedPath = path6.join(thoughtsDir, "shared");
-  const globalPath = path6.join(thoughtsDir, "global");
-  const hasUser = fs4.existsSync(userPath) && fs4.lstatSync(userPath).isSymbolicLink();
-  const hasShared = fs4.existsSync(sharedPath) && fs4.lstatSync(sharedPath).isSymbolicLink();
-  const hasGlobal = fs4.existsSync(globalPath) && fs4.lstatSync(globalPath).isSymbolicLink();
-  if (!hasUser || !hasShared || !hasGlobal) {
-    return {
-      exists: true,
-      isValid: false,
-      message: "thoughts directory exists but symlinks are missing or broken"
-    };
+  if (verbose) {
+    console.log(chalk2.gray("Removing thoughts directory..."));
   }
-  return { exists: true, isValid: true };
+  try {
+    fs4.rmSync(thoughtsDir, { recursive: true, force: true });
+    result.thoughtsRemoved = true;
+  } catch (error) {
+    if (verbose) {
+      console.error(chalk2.red(`Error removing thoughts directory: ${error}`));
+    }
+    throw error;
+  }
+  if (mappedName) {
+    if (verbose) {
+      console.log(chalk2.gray("Removing repository from thoughts configuration..."));
+    }
+    delete config.repoMappings[repoPath];
+    result.configRemoved = true;
+  }
+  return result;
+}
+
+// src/commands/thoughts/init-core.ts
+import fs5 from "fs";
+import path8 from "path";
+import { execSync as execSync3 } from "child_process";
+function setupThoughtsDirectory(options) {
+  const { repoPath, profileConfig, mappedName, user, createSearchable = false, setupHooks = false } = options;
+  const thoughtsDir = path8.join(repoPath, "thoughts");
+  if (fs5.existsSync(thoughtsDir)) {
+    const searchableDir = path8.join(thoughtsDir, "searchable");
+    if (fs5.existsSync(searchableDir)) {
+      try {
+        execSync3(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
+      } catch {
+      }
+    }
+    fs5.rmSync(thoughtsDir, { recursive: true, force: true });
+  }
+  fs5.mkdirSync(thoughtsDir);
+  const repoTarget = getRepoThoughtsPath(profileConfig, mappedName);
+  const globalTarget = getGlobalThoughtsPath(profileConfig);
+  fs5.symlinkSync(path8.join(repoTarget, user), path8.join(thoughtsDir, user), "dir");
+  fs5.symlinkSync(path8.join(repoTarget, "shared"), path8.join(thoughtsDir, "shared"), "dir");
+  fs5.symlinkSync(globalTarget, path8.join(thoughtsDir, "global"), "dir");
+  const otherUsers = updateSymlinksForNewUsers(
+    repoPath,
+    profileConfig,
+    mappedName,
+    user
+  );
+  const claudeMd = generateClaudeMd({
+    thoughtsRepo: profileConfig.thoughtsRepo,
+    reposDir: profileConfig.reposDir,
+    repoName: mappedName,
+    user
+  });
+  fs5.writeFileSync(path8.join(thoughtsDir, "CLAUDE.md"), claudeMd);
+  let hooksUpdated = [];
+  if (setupHooks) {
+    const hookResult = setupGitHooks(repoPath);
+    hooksUpdated = hookResult.updated;
+  }
+  if (createSearchable) {
+    createSearchableIndex(thoughtsDir);
+  }
+  return {
+    thoughtsDir,
+    otherUsers,
+    hooksUpdated
+  };
 }
 function setupGitHooks(repoPath) {
   const updated = [];
   let gitCommonDir;
   try {
-    gitCommonDir = execSync2("git rev-parse --git-common-dir", {
+    gitCommonDir = execSync3("git rev-parse --git-common-dir", {
       cwd: repoPath,
       encoding: "utf8",
       stdio: "pipe"
     }).trim();
-    if (!path6.isAbsolute(gitCommonDir)) {
-      gitCommonDir = path6.join(repoPath, gitCommonDir);
+    if (!path8.isAbsolute(gitCommonDir)) {
+      gitCommonDir = path8.join(repoPath, gitCommonDir);
     }
   } catch (error) {
     throw new Error(`Failed to find git common directory: ${error}`);
   }
-  const hooksDir = path6.join(gitCommonDir, "hooks");
-  if (!fs4.existsSync(hooksDir)) {
-    fs4.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path8.join(gitCommonDir, "hooks");
+  if (!fs5.existsSync(hooksDir)) {
+    fs5.mkdirSync(hooksDir, { recursive: true });
   }
-  const preCommitPath = path6.join(hooksDir, "pre-commit");
+  const preCommitPath = path8.join(hooksDir, "pre-commit");
   const preCommitContent = generatePreCommitHook({ hookPath: preCommitPath });
-  const postCommitPath = path6.join(hooksDir, "post-commit");
+  const postCommitPath = path8.join(hooksDir, "post-commit");
   const postCommitContent = generatePostCommitHook({ hookPath: postCommitPath });
   const hookNeedsUpdate = (hookPath) => {
-    if (!fs4.existsSync(hookPath)) return true;
-    const content = fs4.readFileSync(hookPath, "utf8");
+    if (!fs5.existsSync(hookPath)) return true;
+    const content = fs5.readFileSync(hookPath, "utf8");
     if (!content.includes("ThoughtCabinet thoughts")) return false;
     const versionMatch = content.match(/# Version: (\d+)/);
     if (!versionMatch) return true;
     const currentVersion = parseInt(versionMatch[1]);
     return currentVersion < parseInt(HOOK_VERSION);
   };
-  if (fs4.existsSync(preCommitPath)) {
-    const content = fs4.readFileSync(preCommitPath, "utf8");
+  if (fs5.existsSync(preCommitPath)) {
+    const content = fs5.readFileSync(preCommitPath, "utf8");
     if (!content.includes("ThoughtCabinet thoughts") || hookNeedsUpdate(preCommitPath)) {
       if (!content.includes("ThoughtCabinet thoughts")) {
-        fs4.renameSync(preCommitPath, `${preCommitPath}.old`);
+        fs5.renameSync(preCommitPath, `${preCommitPath}.old`);
       } else {
-        fs4.unlinkSync(preCommitPath);
+        fs5.unlinkSync(preCommitPath);
       }
     }
   }
-  if (fs4.existsSync(postCommitPath)) {
-    const content = fs4.readFileSync(postCommitPath, "utf8");
+  if (fs5.existsSync(postCommitPath)) {
+    const content = fs5.readFileSync(postCommitPath, "utf8");
     if (!content.includes("ThoughtCabinet thoughts") || hookNeedsUpdate(postCommitPath)) {
       if (!content.includes("ThoughtCabinet thoughts")) {
-        fs4.renameSync(postCommitPath, `${postCommitPath}.old`);
+        fs5.renameSync(postCommitPath, `${postCommitPath}.old`);
       } else {
-        fs4.unlinkSync(postCommitPath);
+        fs5.unlinkSync(postCommitPath);
       }
     }
   }
-  if (!fs4.existsSync(preCommitPath) || hookNeedsUpdate(preCommitPath)) {
-    fs4.writeFileSync(preCommitPath, preCommitContent);
-    fs4.chmodSync(preCommitPath, "755");
+  if (!fs5.existsSync(preCommitPath) || hookNeedsUpdate(preCommitPath)) {
+    fs5.writeFileSync(preCommitPath, preCommitContent);
+    fs5.chmodSync(preCommitPath, "755");
     updated.push("pre-commit");
   }
-  if (!fs4.existsSync(postCommitPath) || hookNeedsUpdate(postCommitPath)) {
-    fs4.writeFileSync(postCommitPath, postCommitContent);
-    fs4.chmodSync(postCommitPath, "755");
+  if (!fs5.existsSync(postCommitPath) || hookNeedsUpdate(postCommitPath)) {
+    fs5.writeFileSync(postCommitPath, postCommitContent);
+    fs5.chmodSync(postCommitPath, "755");
     updated.push("post-commit");
   }
   return { updated };
 }
+function createSearchableIndex(thoughtsDir) {
+  const searchDir = path8.join(thoughtsDir, "searchable");
+  if (fs5.existsSync(searchDir)) {
+    try {
+      execSync3(`chmod -R 755 "${searchDir}"`, { stdio: "pipe" });
+    } catch {
+    }
+    fs5.rmSync(searchDir, { recursive: true, force: true });
+  }
+  fs5.mkdirSync(searchDir, { recursive: true });
+  function findFilesFollowingSymlinks(dir, baseDir = dir, visited = /* @__PURE__ */ new Set()) {
+    const files = [];
+    const realPath = fs5.realpathSync(dir);
+    if (visited.has(realPath)) {
+      return files;
+    }
+    visited.add(realPath);
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        files.push(...findFilesFollowingSymlinks(fullPath, baseDir, visited));
+      } else if (entry.isSymbolicLink() && !entry.name.startsWith(".")) {
+        try {
+          const stat = fs5.statSync(fullPath);
+          if (stat.isDirectory()) {
+            files.push(...findFilesFollowingSymlinks(fullPath, baseDir, visited));
+          } else if (stat.isFile() && path8.basename(fullPath) !== "CLAUDE.md") {
+            files.push(path8.relative(baseDir, fullPath));
+          }
+        } catch {
+        }
+      } else if (entry.isFile() && !entry.name.startsWith(".") && entry.name !== "CLAUDE.md") {
+        files.push(path8.relative(baseDir, fullPath));
+      }
+    }
+    return files;
+  }
+  const allFiles = findFilesFollowingSymlinks(thoughtsDir);
+  let linkedCount = 0;
+  for (const relPath of allFiles) {
+    const sourcePath = path8.join(thoughtsDir, relPath);
+    const targetPath = path8.join(searchDir, relPath);
+    const targetDir = path8.dirname(targetPath);
+    if (!fs5.existsSync(targetDir)) {
+      fs5.mkdirSync(targetDir, { recursive: true });
+    }
+    try {
+      const realSourcePath = fs5.realpathSync(sourcePath);
+      fs5.linkSync(realSourcePath, targetPath);
+      linkedCount++;
+    } catch {
+    }
+  }
+  return linkedCount;
+}
+function pullThoughtsFromRemote(thoughtsRepo) {
+  const expandedRepo = expandPath(thoughtsRepo);
+  try {
+    execSync3("git remote get-url origin", { cwd: expandedRepo, stdio: "pipe" });
+    try {
+      execSync3("git pull --rebase", {
+        stdio: "pipe",
+        cwd: expandedRepo
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+// src/hooks/loader.ts
+import fs6 from "fs";
+import path9 from "path";
+import chalk3 from "chalk";
+var HOOKS_CONFIG_DIR = ".thought-cabinet";
+var HOOKS_CONFIG_FILE = `${HOOKS_CONFIG_DIR}/hooks.json`;
+function loadHooksConfig(repoPath) {
+  const configPath = path9.join(repoPath, HOOKS_CONFIG_FILE);
+  if (!fs6.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = fs6.readFileSync(configPath, "utf8");
+    const config = JSON.parse(content);
+    if (!config.hooks || typeof config.hooks !== "object") {
+      console.error(
+        chalk3.yellow(`Warning: Invalid hooks config at ${configPath}: missing 'hooks' object`)
+      );
+      return null;
+    }
+    return config;
+  } catch (error) {
+    console.error(
+      chalk3.yellow(
+        `Warning: Could not parse hooks config at ${configPath}: ${error.message}`
+      )
+    );
+    return null;
+  }
+}
+function getHooksForEvent(config, event) {
+  const hookGroups = config?.hooks[event];
+  if (!hookGroups) {
+    return [];
+  }
+  return hookGroups.flatMap((group) => group.hooks ?? []);
+}
+
+// src/hooks/executor.ts
+import { spawn } from "child_process";
+import chalk4 from "chalk";
+var DEFAULT_TIMEOUT_SECONDS = 60;
+function resolveExitCode(exitCode, timedOut) {
+  if (exitCode !== null) {
+    return exitCode;
+  }
+  if (timedOut) {
+    return 124;
+  }
+  return 1;
+}
+async function executeHook(hook, input, env = {}) {
+  const startTime = Date.now();
+  const timeoutMs = (hook.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1e3;
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const child = spawn("bash", ["-c", hook.command], {
+      cwd: input.cwd,
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 5e3);
+    }, timeoutMs);
+    child.stdin.write(JSON.stringify(input, null, 2));
+    child.stdin.end();
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (exitCode) => {
+      clearTimeout(timer);
+      const duration = Date.now() - startTime;
+      resolve({
+        success: exitCode === 0 && !timedOut,
+        exitCode: resolveExitCode(exitCode, timedOut),
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        timedOut,
+        duration
+      });
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      const duration = Date.now() - startTime;
+      resolve({
+        success: false,
+        exitCode: 1,
+        stdout: stdout.trim(),
+        stderr: `Failed to execute hook: ${error.message}`,
+        timedOut: false,
+        duration
+      });
+    });
+  });
+}
+function displayHookResult(hook, result, verbose) {
+  const timeoutSeconds = hook.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+  if (result.timedOut) {
+    console.log(chalk4.yellow(`Warning: Hook timed out after ${timeoutSeconds}s: ${hook.command}`));
+    if (result.stderr) {
+      console.log(chalk4.yellow(result.stderr));
+    }
+    return;
+  }
+  switch (result.exitCode) {
+    case 0:
+      console.log(chalk4.gray(`Hook completed (${result.duration}ms): ${hook.command}`));
+      if (verbose && result.stdout) {
+        console.log(chalk4.gray(result.stdout));
+      }
+      break;
+    case 2:
+      console.log(chalk4.red(`Hook failed with exit code 2: ${hook.command}`));
+      if (result.stderr) {
+        console.log(chalk4.red(result.stderr));
+      }
+      break;
+    default:
+      console.log(
+        chalk4.yellow(`Warning: Hook failed with exit code ${result.exitCode}: ${hook.command}`)
+      );
+      if (verbose && result.stderr) {
+        console.log(chalk4.yellow(result.stderr));
+      }
+  }
+}
+async function executeHooks(hooks, input, env = {}, verbose = false) {
+  if (hooks.length === 0) {
+    return [];
+  }
+  if (verbose) {
+    console.log(chalk4.gray(`
+Executing ${hooks.length} hook(s) for ${input.hook_event_name}...`));
+  }
+  const results = await Promise.all(hooks.map((hook) => executeHook(hook, input, env)));
+  for (let i = 0; i < results.length; i++) {
+    displayHookResult(hooks[i], results[i], verbose);
+  }
+  return results;
+}
+
+// src/commands/thoughts/init.ts
+function sanitizeDirectoryName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function checkExistingSetup(config) {
+  const thoughtsDir = path10.join(process.cwd(), "thoughts");
+  if (!fs7.existsSync(thoughtsDir)) {
+    return { exists: false, isValid: false };
+  }
+  if (!fs7.lstatSync(thoughtsDir).isDirectory()) {
+    return { exists: true, isValid: false, message: "thoughts exists but is not a directory" };
+  }
+  if (!config) {
+    return {
+      exists: true,
+      isValid: false,
+      message: "thoughts directory exists but configuration is missing"
+    };
+  }
+  const userPath = path10.join(thoughtsDir, config.user);
+  const sharedPath = path10.join(thoughtsDir, "shared");
+  const globalPath = path10.join(thoughtsDir, "global");
+  const hasUser = fs7.existsSync(userPath) && fs7.lstatSync(userPath).isSymbolicLink();
+  const hasShared = fs7.existsSync(sharedPath) && fs7.lstatSync(sharedPath).isSymbolicLink();
+  const hasGlobal = fs7.existsSync(globalPath) && fs7.lstatSync(globalPath).isSymbolicLink();
+  if (!hasUser || !hasShared || !hasGlobal) {
+    return {
+      exists: true,
+      isValid: false,
+      message: "thoughts directory exists but symlinks are missing or broken"
+    };
+  }
+  return { exists: true, isValid: true };
+}
 async function thoughtsInitCommand(options) {
   try {
     if (!options.directory && !process.stdin.isTTY) {
@@ -558,18 +1001,18 @@ async function thoughtsInitCommand(options) {
     }
     const currentRepo = getCurrentRepoPath();
     try {
-      execSync2("git rev-parse --git-dir", { stdio: "pipe" });
+      execSync4("git rev-parse --git-dir", { stdio: "pipe" });
     } catch {
       p.log.error("Not in a git repository");
       process.exit(1);
     }
     let config = loadThoughtsConfig(options);
     if (!config) {
-      p.intro(chalk2.blue("Initial Thoughts Setup"));
+      p.intro(chalk5.blue("Initial Thoughts Setup"));
       p.log.info("First, let's configure your global thoughts system.");
       const defaultRepo = getDefaultThoughtsRepo();
       p.log.message(
-        chalk2.gray("This is where all your thoughts across all projects will be stored.")
+        chalk5.gray("This is where all your thoughts across all projects will be stored.")
       );
       const thoughtsRepoInput = await p.text({
         message: "Thoughts repository location:",
@@ -581,9 +1024,9 @@ async function thoughtsInitCommand(options) {
         process.exit(0);
       }
       const thoughtsRepo = thoughtsRepoInput || defaultRepo;
-      p.log.message(chalk2.gray("Your thoughts will be organized into two main directories:"));
-      p.log.message(chalk2.gray("- Repository-specific thoughts (one subdirectory per project)"));
-      p.log.message(chalk2.gray("- Global thoughts (shared across all projects)"));
+      p.log.message(chalk5.gray("Your thoughts will be organized into two main directories:"));
+      p.log.message(chalk5.gray("- Repository-specific thoughts (one subdirectory per project)"));
+      p.log.message(chalk5.gray("- Global thoughts (shared across all projects)"));
       const reposDirInput = await p.text({
         message: "Directory name for repository-specific thoughts:",
         initialValue: "repos",
@@ -632,9 +1075,9 @@ async function thoughtsInitCommand(options) {
         repoMappings: {}
       };
       p.note(
-        `${chalk2.cyan(thoughtsRepo)}/
-  \u251C\u2500\u2500 ${chalk2.cyan(reposDir2)}/     ${chalk2.gray("(project-specific thoughts)")}
-  \u2514\u2500\u2500 ${chalk2.cyan(globalDir)}/    ${chalk2.gray("(cross-project thoughts)")}`,
+        `${chalk5.cyan(thoughtsRepo)}/
+  \u251C\u2500\u2500 ${chalk5.cyan(reposDir2)}/     ${chalk5.gray("(project-specific thoughts)")}
+  \u2514\u2500\u2500 ${chalk5.cyan(globalDir)}/    ${chalk5.gray("(cross-project thoughts)")}`,
         "Creating thoughts structure"
       );
       ensureThoughtsRepoExists(thoughtsRepo, reposDir2, globalDir);
@@ -644,16 +1087,16 @@ async function thoughtsInitCommand(options) {
     if (options.profile) {
       if (!validateProfile(config, options.profile)) {
         p.log.error(`Profile "${options.profile}" does not exist.`);
-        p.log.message(chalk2.gray("Available profiles:"));
+        p.log.message(chalk5.gray("Available profiles:"));
         if (config.profiles) {
           Object.keys(config.profiles).forEach((name) => {
-            p.log.message(chalk2.gray(`  - ${name}`));
+            p.log.message(chalk5.gray(`  - ${name}`));
           });
         } else {
-          p.log.message(chalk2.gray("  (none)"));
+          p.log.message(chalk5.gray("  (none)"));
         }
         p.log.warn("Create a profile first:");
-        p.log.message(chalk2.gray(`  thoughtcabinet profile create ${options.profile}`));
+        p.log.message(chalk5.gray(`  thoughtcabinet profile create ${options.profile}`));
         process.exit(1);
       }
     }
@@ -692,8 +1135,8 @@ async function thoughtsInitCommand(options) {
         }
       }
     }
-    const expandedRepo = expandPath(tempProfileConfig.thoughtsRepo);
-    if (!fs4.existsSync(expandedRepo)) {
+    let expandedRepo = expandPath(tempProfileConfig.thoughtsRepo);
+    if (!fs7.existsSync(expandedRepo)) {
       p.log.error(`Thoughts repository not found at ${tempProfileConfig.thoughtsRepo}`);
       p.log.warn("The thoughts repository may have been moved or deleted.");
       const recreate = await p.confirm({
@@ -710,16 +1153,24 @@ async function thoughtsInitCommand(options) {
         tempProfileConfig.globalDir
       );
     }
-    const reposDir = path6.join(expandedRepo, tempProfileConfig.reposDir);
-    if (!fs4.existsSync(reposDir)) {
-      fs4.mkdirSync(reposDir, { recursive: true });
+    const reposDir = path10.join(expandedRepo, tempProfileConfig.reposDir);
+    if (!fs7.existsSync(reposDir)) {
+      fs7.mkdirSync(reposDir, { recursive: true });
     }
-    const existingRepos = fs4.readdirSync(reposDir).filter((name) => {
-      const fullPath = path6.join(reposDir, name);
-      return fs4.statSync(fullPath).isDirectory() && !name.startsWith(".");
+    const existingRepos = fs7.readdirSync(reposDir).filter((name) => {
+      const fullPath = path10.join(reposDir, name);
+      return fs7.statSync(fullPath).isDirectory() && !name.startsWith(".");
     });
     const existingMapping = config.repoMappings[currentRepo];
     let mappedName = getRepoNameFromMapping(existingMapping);
+    let mainRepoMapping;
+    let mainRepoPath = null;
+    if (!mappedName) {
+      mainRepoPath = getMainRepoPath();
+      if (mainRepoPath && config.repoMappings[mainRepoPath]) {
+        mainRepoMapping = config.repoMappings[mainRepoPath];
+      }
+    }
     if (!mappedName) {
       if (options.directory) {
         const sanitizedDir = sanitizeDirectoryName(options.directory);
@@ -728,7 +1179,7 @@ async function thoughtsInitCommand(options) {
           p.log.error("In non-interactive mode (--directory), you must specify a directory");
           p.log.error("name that already exists in the thoughts repository.");
           p.log.warn("Available directories:");
-          existingRepos.forEach((repo) => p.log.message(chalk2.gray(`  - ${repo}`)));
+          existingRepos.forEach((repo) => p.log.message(chalk5.gray(`  - ${repo}`)));
           process.exit(1);
         }
         mappedName = sanitizedDir;
@@ -736,22 +1187,36 @@ async function thoughtsInitCommand(options) {
           `Using existing: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/${mappedName}`
         );
       } else {
-        p.intro(chalk2.blue("Repository Setup"));
-        p.log.info(`Setting up thoughts for: ${chalk2.cyan(currentRepo)}`);
+        p.intro(chalk5.blue("Repository Setup"));
+        p.log.info(`Setting up thoughts for: ${chalk5.cyan(currentRepo)}`);
         p.log.message(
-          chalk2.gray(
+          chalk5.gray(
             `This will create a subdirectory in ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/`
           )
         );
-        p.log.message(chalk2.gray("to store thoughts specific to this repository."));
-        if (existingRepos.length > 0) {
-          const selectOptions = [
-            ...existingRepos.map((repo) => ({ value: repo, label: `Use existing: ${repo}` })),
-            { value: "__create_new__", label: "Create new directory" }
-          ];
+        p.log.message(chalk5.gray("to store thoughts specific to this repository."));
+        if (existingRepos.length > 0 || mainRepoMapping) {
+          const selectOptions = [];
+          let initialValue;
+          const mainRepoMappedName = getRepoNameFromMapping(mainRepoMapping);
+          if (mainRepoMappedName && existingRepos.includes(mainRepoMappedName)) {
+            selectOptions.push({
+              value: mainRepoMappedName,
+              label: `Use existing: ${mainRepoMappedName} (from main repository)`
+            });
+            initialValue = mainRepoMappedName;
+          }
+          existingRepos.filter((repo) => repo !== mainRepoMappedName).forEach((repo) => {
+            selectOptions.push({ value: repo, label: `Use existing: ${repo}` });
+          });
+          selectOptions.push({ value: "__create_new__", label: "Create new directory" });
+          if (!initialValue) {
+            initialValue = "__create_new__";
+          }
           const selection = await p.select({
             message: "Select or create a thoughts directory for this repository:",
-            options: selectOptions
+            options: selectOptions,
+            initialValue
           });
           if (p.isCancel(selection)) {
             p.cancel("Operation cancelled.");
@@ -760,7 +1225,7 @@ async function thoughtsInitCommand(options) {
           if (selection === "__create_new__") {
             const defaultName = getRepoNameFromPath(currentRepo);
             p.log.message(
-              chalk2.gray(
+              chalk5.gray(
                 `This name will be used for the directory: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/[name]`
               )
             );
@@ -780,6 +1245,13 @@ async function thoughtsInitCommand(options) {
             );
           } else {
             mappedName = selection;
+            if (mainRepoMapping && mappedName === mainRepoMappedName) {
+              const inheritedProfile2 = getProfileNameFromMapping(mainRepoMapping);
+              if (inheritedProfile2 && !options.profile) {
+                options.profile = inheritedProfile2;
+                p.log.info(`Inheriting profile "${inheritedProfile2}" from main repository`);
+              }
+            }
             p.log.success(
               `Will use existing: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/${mappedName}`
             );
@@ -787,7 +1259,7 @@ async function thoughtsInitCommand(options) {
         } else {
           const defaultName = getRepoNameFromPath(currentRepo);
           p.log.message(
-            chalk2.gray(
+            chalk5.gray(
               `This name will be used for the directory: ${tempProfileConfig.thoughtsRepo}/${tempProfileConfig.reposDir}/[name]`
             )
           );
@@ -816,29 +1288,36 @@ async function thoughtsInitCommand(options) {
         config.repoMappings[currentRepo] = mappedName;
       }
       saveThoughtsConfig(config, options);
+      const inheritedProfile = getProfileNameFromMapping(mainRepoMapping);
+      if (inheritedProfile && options.profile === inheritedProfile && tempProfileConfig.profileName !== inheritedProfile) {
+        const profileSettings = config.profiles?.[inheritedProfile];
+        if (profileSettings) {
+          expandedRepo = expandPath(profileSettings.thoughtsRepo);
+        }
+      }
     }
     if (!mappedName) {
       mappedName = getRepoNameFromMapping(config.repoMappings[currentRepo]);
     }
     const profileConfig = resolveProfileForRepo(config, currentRepo);
     createThoughtsDirectoryStructure(profileConfig, mappedName, config.user);
-    const thoughtsDir = path6.join(currentRepo, "thoughts");
-    if (fs4.existsSync(thoughtsDir)) {
-      const searchableDir = path6.join(thoughtsDir, "searchable");
-      if (fs4.existsSync(searchableDir)) {
+    const thoughtsDir = path10.join(currentRepo, "thoughts");
+    if (fs7.existsSync(thoughtsDir)) {
+      const searchableDir = path10.join(thoughtsDir, "searchable");
+      if (fs7.existsSync(searchableDir)) {
         try {
-          execSync2(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
+          execSync4(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
         } catch {
         }
       }
-      fs4.rmSync(thoughtsDir, { recursive: true, force: true });
+      fs7.rmSync(thoughtsDir, { recursive: true, force: true });
     }
-    fs4.mkdirSync(thoughtsDir);
+    fs7.mkdirSync(thoughtsDir);
     const repoTarget = getRepoThoughtsPath(profileConfig, mappedName);
     const globalTarget = getGlobalThoughtsPath(profileConfig);
-    fs4.symlinkSync(path6.join(repoTarget, config.user), path6.join(thoughtsDir, config.user), "dir");
-    fs4.symlinkSync(path6.join(repoTarget, "shared"), path6.join(thoughtsDir, "shared"), "dir");
-    fs4.symlinkSync(globalTarget, path6.join(thoughtsDir, "global"), "dir");
+    fs7.symlinkSync(path10.join(repoTarget, config.user), path10.join(thoughtsDir, config.user), "dir");
+    fs7.symlinkSync(path10.join(repoTarget, "shared"), path10.join(thoughtsDir, "shared"), "dir");
+    fs7.symlinkSync(globalTarget, path10.join(thoughtsDir, "global"), "dir");
     const otherUsers = updateSymlinksForNewUsers(
       currentRepo,
       profileConfig,
@@ -848,18 +1327,8 @@ async function thoughtsInitCommand(options) {
     if (otherUsers.length > 0) {
       p.log.success(`Added symlinks for other users: ${otherUsers.join(", ")}`);
     }
-    try {
-      execSync2("git remote get-url origin", { cwd: expandedRepo, stdio: "pipe" });
-      try {
-        execSync2("git pull --rebase", {
-          stdio: "pipe",
-          cwd: expandedRepo
-        });
-        p.log.success("Pulled latest thoughts from remote");
-      } catch (error) {
-        p.log.warn(`Could not pull latest thoughts: ${error.message}`);
-      }
-    } catch {
+    if (pullThoughtsFromRemote(expandedRepo)) {
+      p.log.success("Pulled latest thoughts from remote");
     }
     const claudeMd = generateClaudeMd({
       thoughtsRepo: profileConfig.thoughtsRepo,
@@ -867,34 +1336,55 @@ async function thoughtsInitCommand(options) {
       repoName: mappedName,
       user: config.user
     });
-    fs4.writeFileSync(path6.join(thoughtsDir, "CLAUDE.md"), claudeMd);
+    fs7.writeFileSync(path10.join(thoughtsDir, "CLAUDE.md"), claudeMd);
     const hookResult = setupGitHooks(currentRepo);
     if (hookResult.updated.length > 0) {
       p.log.step(`Updated git hooks: ${hookResult.updated.join(", ")}`);
     }
     p.log.success("Thoughts setup complete!");
-    const structureText = `${chalk2.cyan(currentRepo)}/
+    const structureText = `${chalk5.cyan(currentRepo)}/
   \u2514\u2500\u2500 thoughts/
-       \u251C\u2500\u2500 ${config.user}/     ${chalk2.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.reposDir}/${mappedName}/${config.user}/`)}
-       \u251C\u2500\u2500 shared/      ${chalk2.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.reposDir}/${mappedName}/shared/`)}
-       \u2514\u2500\u2500 global/      ${chalk2.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.globalDir}/`)}
-           \u251C\u2500\u2500 ${config.user}/     ${chalk2.gray("(your cross-repo notes)")}
-           \u2514\u2500\u2500 shared/  ${chalk2.gray("(team cross-repo notes)")}`;
+       \u251C\u2500\u2500 ${config.user}/     ${chalk5.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.reposDir}/${mappedName}/${config.user}/`)}
+       \u251C\u2500\u2500 shared/      ${chalk5.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.reposDir}/${mappedName}/shared/`)}
+       \u2514\u2500\u2500 global/      ${chalk5.gray(`\u2192 ${profileConfig.thoughtsRepo}/${profileConfig.globalDir}/`)}
+           \u251C\u2500\u2500 ${config.user}/     ${chalk5.gray("(your cross-repo notes)")}
+           \u2514\u2500\u2500 shared/  ${chalk5.gray("(team cross-repo notes)")}`;
     p.note(structureText, "Repository structure created");
     p.note(
-      `${chalk2.green("\u2713")} Pre-commit hook: Prevents committing thoughts/
-${chalk2.green("\u2713")} Post-commit hook: Auto-syncs thoughts after commits`,
+      `${chalk5.green("\u2713")} Pre-commit hook: Prevents committing thoughts/
+${chalk5.green("\u2713")} Post-commit hook: Auto-syncs thoughts after commits`,
       "Protection enabled"
     );
+    const hooksConfig = loadHooksConfig(currentRepo);
+    const postInitHooks = getHooksForEvent(hooksConfig, "PostThoughtsInit");
+    if (postInitHooks.length > 0) {
+      const hookInput = {
+        hook_event_name: "PostThoughtsInit",
+        cwd: currentRepo,
+        thoughts_repo: profileConfig.thoughtsRepo,
+        repos_dir: profileConfig.reposDir,
+        global_dir: profileConfig.globalDir,
+        mapped_name: mappedName,
+        user: config.user
+      };
+      const hookEnv = {
+        THC_THOUGHTS_REPO: profileConfig.thoughtsRepo,
+        THC_REPOS_DIR: profileConfig.reposDir,
+        THC_GLOBAL_DIR: profileConfig.globalDir,
+        THC_MAPPED_NAME: mappedName,
+        THC_USER: config.user
+      };
+      await executeHooks(postInitHooks, hookInput, hookEnv, true);
+    }
     p.outro(
-      chalk2.gray("Next steps:\n") + chalk2.gray(
-        `  1. Run ${chalk2.cyan("thoughtcabinet sync")} to create the searchable index
+      chalk5.gray("Next steps:\n") + chalk5.gray(
+        `  1. Run ${chalk5.cyan("thoughtcabinet sync")} to create the searchable index
 `
-      ) + chalk2.gray(
-        `  2. Create markdown files in ${chalk2.cyan(`thoughts/${config.user}/`)} for your notes
+      ) + chalk5.gray(
+        `  2. Create markdown files in ${chalk5.cyan(`thoughts/${config.user}/`)} for your notes
 `
-      ) + chalk2.gray(`  3. Your thoughts will sync automatically when you commit code
-`) + chalk2.gray(`  4. Run ${chalk2.cyan("thoughtcabinet status")} to check sync status`)
+      ) + chalk5.gray(`  3. Your thoughts will sync automatically when you commit code
+`) + chalk5.gray(`  4. Run ${chalk5.cyan("thoughtcabinet status")} to check sync status`)
     );
   } catch (error) {
     p.log.error(`Error during thoughts init: ${error}`);
@@ -903,81 +1393,84 @@ ${chalk2.green("\u2713")} Post-commit hook: Auto-syncs thoughts after commits`,
 }
 
 // src/commands/thoughts/destroy.ts
-import fs5 from "fs";
-import path7 from "path";
-import { execSync as execSync3 } from "child_process";
-import chalk3 from "chalk";
+import fs8 from "fs";
+import path11 from "path";
+import chalk6 from "chalk";
 async function thoughtsDestoryCommand(options) {
   try {
     const currentRepo = getCurrentRepoPath();
-    const thoughtsDir = path7.join(currentRepo, "thoughts");
-    if (!fs5.existsSync(thoughtsDir)) {
-      console.error(chalk3.red("Error: Thoughts not initialized for this repository."));
-      process.exit(1);
-    }
-    const config = loadThoughtsConfig(options);
-    if (!config) {
-      console.error(chalk3.red("Error: Thoughts configuration not found."));
-      process.exit(1);
-    }
-    const mapping = config.repoMappings[currentRepo];
-    const mappedName = getRepoNameFromMapping(mapping);
-    const profileName = getProfileNameFromMapping(mapping);
-    if (!mappedName && !options.force) {
-      console.error(chalk3.red("Error: This repository is not in the thoughts configuration."));
-      console.error(chalk3.yellow("Use --force to remove the thoughts directory anyway."));
-      process.exit(1);
-    }
-    console.log(chalk3.blue("Removing thoughts setup from current repository..."));
-    const searchableDir = path7.join(thoughtsDir, "searchable");
-    if (fs5.existsSync(searchableDir)) {
-      console.log(chalk3.gray("Removing searchable directory..."));
-      try {
-        execSync3(`chmod -R 755 "${searchableDir}"`, { stdio: "pipe" });
-      } catch {
-      }
-      fs5.rmSync(searchableDir, { recursive: true, force: true });
+    const thoughtsDir = path11.join(currentRepo, "thoughts");
+    if (!fs8.existsSync(thoughtsDir)) {
+      console.error(chalk6.red("Error: Thoughts not initialized for this repository."));
+      process.exit(1);
     }
-    console.log(chalk3.gray("Removing thoughts directory (symlinks only)..."));
-    try {
-      fs5.rmSync(thoughtsDir, { recursive: true, force: true });
-    } catch (error) {
-      console.error(chalk3.red(`Error removing thoughts directory: ${error}`));
-      console.error(chalk3.yellow("You may need to manually remove: " + thoughtsDir));
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk6.red("Error: Thoughts configuration not found."));
       process.exit(1);
     }
-    if (mappedName) {
-      console.log(chalk3.gray("Removing repository from thoughts configuration..."));
-      delete config.repoMappings[currentRepo];
+    const mapping = config.repoMappings[currentRepo];
+    if (!mapping && !options.force) {
+      console.error(chalk6.red("Error: This repository is not in the thoughts configuration."));
+      console.error(chalk6.yellow("Use --force to remove the thoughts directory anyway."));
+      process.exit(1);
+    }
+    console.log(chalk6.blue("Removing thoughts setup from current repository..."));
+    const result = cleanupThoughtsDirectory({
+      repoPath: currentRepo,
+      config,
+      force: options.force,
+      verbose: true
+    });
+    if (result.configRemoved) {
       saveThoughtsConfig(config, options);
     }
-    console.log(chalk3.green("\u2705 Thoughts removed from repository"));
-    if (mappedName) {
+    console.log(chalk6.green("\u2705 Thoughts removed from repository"));
+    if (result.mappedName) {
       console.log("");
-      console.log(chalk3.gray("Note: Your thoughts content remains safe in:"));
-      if (profileName && config.profiles && config.profiles[profileName]) {
-        const profile = config.profiles[profileName];
-        console.log(chalk3.gray(`  ${profile.thoughtsRepo}/${profile.reposDir}/${mappedName}`));
-        console.log(chalk3.gray(`  (profile: ${profileName})`));
+      console.log(chalk6.gray("Note: Your thoughts content remains safe in:"));
+      if (result.profileName && config.profiles && config.profiles[result.profileName]) {
+        const profile = config.profiles[result.profileName];
+        console.log(chalk6.gray(`  ${profile.thoughtsRepo}/${profile.reposDir}/${result.mappedName}`));
+        console.log(chalk6.gray(`  (profile: ${result.profileName})`));
       } else {
-        console.log(chalk3.gray(`  ${config.thoughtsRepo}/${config.reposDir}/${mappedName}`));
+        console.log(chalk6.gray(`  ${config.thoughtsRepo}/${config.reposDir}/${result.mappedName}`));
       }
-      console.log(chalk3.gray("Only the local symlinks and configuration were removed."));
+      console.log(chalk6.gray("Only the local symlinks and configuration were removed."));
+    }
+    const hooksConfig = loadHooksConfig(currentRepo);
+    const postDestroyHooks = getHooksForEvent(hooksConfig, "PostThoughtsDestroy");
+    if (postDestroyHooks.length > 0) {
+      const hookInput = {
+        hook_event_name: "PostThoughtsDestroy",
+        cwd: currentRepo,
+        thoughts_removed: result.thoughtsRemoved,
+        config_removed: result.configRemoved,
+        mapped_name: result.mappedName,
+        profile_name: result.profileName
+      };
+      const hookEnv = {
+        THC_THOUGHTS_REMOVED: result.thoughtsRemoved ? "true" : "false",
+        THC_CONFIG_REMOVED: result.configRemoved ? "true" : "false",
+        THC_MAPPED_NAME: result.mappedName || "",
+        THC_PROFILE_NAME: result.profileName || ""
+      };
+      await executeHooks(postDestroyHooks, hookInput, hookEnv, true);
     }
   } catch (error) {
-    console.error(chalk3.red(`Error during thoughts destroy: ${error}`));
+    console.error(chalk6.red(`Error during thoughts destroy: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/sync.ts
-import fs6 from "fs";
-import path8 from "path";
-import { execSync as execSync4, execFileSync } from "child_process";
-import chalk4 from "chalk";
+import fs9 from "fs";
+import path12 from "path";
+import { execSync as execSync5, execFileSync as execFileSync2 } from "child_process";
+import chalk7 from "chalk";
 function checkGitStatus(repoPath) {
   try {
-    const status = execSync4("git status --porcelain", {
+    const status = execSync5("git status --porcelain", {
       cwd: repoPath,
       encoding: "utf8",
       stdio: "pipe"
@@ -990,115 +1483,59 @@ function checkGitStatus(repoPath) {
 function syncThoughts(thoughtsRepo, message) {
   const expandedRepo = expandPath(thoughtsRepo);
   try {
-    execSync4("git add -A", { cwd: expandedRepo, stdio: "pipe" });
+    execSync5("git add -A", { cwd: expandedRepo, stdio: "pipe" });
     const hasChanges = checkGitStatus(expandedRepo);
     if (hasChanges) {
       const commitMessage = message || `Sync thoughts - ${(/* @__PURE__ */ new Date()).toISOString()}`;
-      execFileSync("git", ["commit", "-m", commitMessage], { cwd: expandedRepo, stdio: "pipe" });
-      console.log(chalk4.green("\u2705 Thoughts synchronized"));
+      execFileSync2("git", ["commit", "-m", commitMessage], { cwd: expandedRepo, stdio: "pipe" });
+      console.log(chalk7.green("\u2705 Thoughts synchronized"));
     } else {
-      console.log(chalk4.gray("No changes to commit"));
+      console.log(chalk7.gray("No changes to commit"));
     }
     try {
-      execSync4("git pull --rebase", {
+      execSync5("git pull --rebase", {
         stdio: "pipe",
         cwd: expandedRepo
       });
     } catch (error) {
       const errorStr = error.toString();
       if (errorStr.includes("CONFLICT (") || errorStr.includes("Automatic merge failed") || errorStr.includes("Patch failed at") || errorStr.includes('When you have resolved this problem, run "git rebase --continue"')) {
-        console.error(chalk4.red("Error: Merge conflict detected in thoughts repository"));
-        console.error(chalk4.red("Please resolve conflicts manually in:"), expandedRepo);
-        console.error(chalk4.red('Then run "git rebase --continue" and "thoughtcabinet sync" again'));
+        console.error(chalk7.red("Error: Merge conflict detected in thoughts repository"));
+        console.error(chalk7.red("Please resolve conflicts manually in:"), expandedRepo);
+        console.error(chalk7.red('Then run "git rebase --continue" and "thoughtcabinet sync" again'));
         process.exit(1);
       } else {
-        console.warn(chalk4.yellow("Warning: Could not pull latest changes:"), error.message);
+        console.warn(chalk7.yellow("Warning: Could not pull latest changes:"), error.message);
       }
     }
     try {
-      execSync4("git remote get-url origin", { cwd: expandedRepo, stdio: "pipe" });
-      console.log(chalk4.gray("Pushing to remote..."));
+      execSync5("git remote get-url origin", { cwd: expandedRepo, stdio: "pipe" });
+      console.log(chalk7.gray("Pushing to remote..."));
       try {
-        execSync4("git push", { cwd: expandedRepo, stdio: "pipe" });
-        console.log(chalk4.green("\u2705 Pushed to remote"));
+        execSync5("git push", { cwd: expandedRepo, stdio: "pipe" });
+        console.log(chalk7.green("\u2705 Pushed to remote"));
       } catch {
-        console.log(chalk4.yellow("\u26A0\uFE0F  Could not push to remote. You may need to push manually."));
+        console.log(chalk7.yellow("\u26A0\uFE0F  Could not push to remote. You may need to push manually."));
       }
     } catch {
-      console.log(chalk4.yellow("\u2139\uFE0F  No remote configured for thoughts repository"));
+      console.log(chalk7.yellow("\u2139\uFE0F  No remote configured for thoughts repository"));
     }
   } catch (error) {
-    console.error(chalk4.red(`Error syncing thoughts: ${error}`));
+    console.error(chalk7.red(`Error syncing thoughts: ${error}`));
     process.exit(1);
   }
 }
-function createSearchDirectory(thoughtsDir) {
-  const searchDir = path8.join(thoughtsDir, "searchable");
-  if (fs6.existsSync(searchDir)) {
-    try {
-      execSync4(`chmod -R 755 "${searchDir}"`, { stdio: "pipe" });
-    } catch {
-    }
-    fs6.rmSync(searchDir, { recursive: true, force: true });
-  }
-  fs6.mkdirSync(searchDir, { recursive: true });
-  function findFilesFollowingSymlinks(dir, baseDir = dir, visited = /* @__PURE__ */ new Set()) {
-    const files = [];
-    const realPath = fs6.realpathSync(dir);
-    if (visited.has(realPath)) {
-      return files;
-    }
-    visited.add(realPath);
-    const entries = fs6.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path8.join(dir, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        files.push(...findFilesFollowingSymlinks(fullPath, baseDir, visited));
-      } else if (entry.isSymbolicLink() && !entry.name.startsWith(".")) {
-        try {
-          const stat = fs6.statSync(fullPath);
-          if (stat.isDirectory()) {
-            files.push(...findFilesFollowingSymlinks(fullPath, baseDir, visited));
-          } else if (stat.isFile() && path8.basename(fullPath) !== "CLAUDE.md") {
-            files.push(path8.relative(baseDir, fullPath));
-          }
-        } catch {
-        }
-      } else if (entry.isFile() && !entry.name.startsWith(".") && entry.name !== "CLAUDE.md") {
-        files.push(path8.relative(baseDir, fullPath));
-      }
-    }
-    return files;
-  }
-  const allFiles = findFilesFollowingSymlinks(thoughtsDir);
-  let linkedCount = 0;
-  for (const relPath of allFiles) {
-    const sourcePath = path8.join(thoughtsDir, relPath);
-    const targetPath = path8.join(searchDir, relPath);
-    const targetDir = path8.dirname(targetPath);
-    if (!fs6.existsSync(targetDir)) {
-      fs6.mkdirSync(targetDir, { recursive: true });
-    }
-    try {
-      const realSourcePath = fs6.realpathSync(sourcePath);
-      fs6.linkSync(realSourcePath, targetPath);
-      linkedCount++;
-    } catch {
-    }
-  }
-  console.log(chalk4.gray(`Created ${linkedCount} hard links in searchable directory`));
-}
 async function thoughtsSyncCommand(options) {
   try {
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk4.red('Error: Thoughts not configured. Run "thoughtcabinet init" first.'));
+      console.error(chalk7.red('Error: Thoughts not configured. Run "thoughtcabinet init" first.'));
       process.exit(1);
     }
     const currentRepo = getCurrentRepoPath();
-    const thoughtsDir = path8.join(currentRepo, "thoughts");
-    if (!fs6.existsSync(thoughtsDir)) {
-      console.error(chalk4.red("Error: Thoughts not initialized for this repository."));
+    const thoughtsDir = path12.join(currentRepo, "thoughts");
+    if (!fs9.existsSync(thoughtsDir)) {
+      console.error(chalk7.red("Error: Thoughts not initialized for this repository."));
       console.error('Run "thoughtcabinet init" to set up thoughts.');
       process.exit(1);
     }
@@ -1113,27 +1550,45 @@ async function thoughtsSyncCommand(options) {
         config.user
       );
       if (newUsers.length > 0) {
-        console.log(chalk4.green(`\u2713 Added symlinks for new users: ${newUsers.join(", ")}`));
+        console.log(chalk7.green(`\u2713 Added symlinks for new users: ${newUsers.join(", ")}`));
       }
     }
-    console.log(chalk4.blue("Creating searchable index..."));
-    createSearchDirectory(thoughtsDir);
-    console.log(chalk4.blue("Syncing thoughts..."));
+    console.log(chalk7.blue("Creating searchable index..."));
+    const linkedCount = createSearchableIndex(thoughtsDir);
+    console.log(chalk7.gray(`Created ${linkedCount} hard links in searchable directory`));
+    console.log(chalk7.blue("Syncing thoughts..."));
     syncThoughts(profileConfig.thoughtsRepo, options.message || "");
+    const hooksConfig = loadHooksConfig(currentRepo);
+    const postSyncHooks = getHooksForEvent(hooksConfig, "PostThoughtsSync");
+    if (postSyncHooks.length > 0) {
+      const hookInput = {
+        hook_event_name: "PostThoughtsSync",
+        cwd: currentRepo,
+        thoughts_repo: profileConfig.thoughtsRepo,
+        has_changes: true,
+        searchable_created: true
+      };
+      const hookEnv = {
+        THC_THOUGHTS_REPO: profileConfig.thoughtsRepo,
+        THC_HAS_CHANGES: "true",
+        THC_SEARCHABLE_CREATED: "true"
+      };
+      await executeHooks(postSyncHooks, hookInput, hookEnv, true);
+    }
   } catch (error) {
-    console.error(chalk4.red(`Error during thoughts sync: ${error}`));
+    console.error(chalk7.red(`Error during thoughts sync: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/status.ts
-import fs7 from "fs";
-import path9 from "path";
-import { execSync as execSync5 } from "child_process";
-import chalk5 from "chalk";
+import fs10 from "fs";
+import path13 from "path";
+import { execSync as execSync6 } from "child_process";
+import chalk8 from "chalk";
 function getGitStatus(repoPath) {
   try {
-    return execSync5("git status -sb", {
+    return execSync6("git status -sb", {
       cwd: repoPath,
       encoding: "utf8",
       stdio: "pipe"
@@ -1144,7 +1599,7 @@ function getGitStatus(repoPath) {
 }
 function getUncommittedChanges(repoPath) {
   try {
-    const output = execSync5("git status --porcelain", {
+    const output = execSync6("git status --porcelain", {
       cwd: repoPath,
       encoding: "utf8",
       stdio: "pipe"
@@ -1158,7 +1613,7 @@ function getUncommittedChanges(repoPath) {
       else if (status[0] === "D") statusText = "deleted";
       else if (status[0] === "?") statusText = "untracked";
       else if (status[0] === "R") statusText = "renamed";
-      return `  ${chalk5.yellow(statusText.padEnd(10))} ${file}`;
+      return `  ${chalk8.yellow(statusText.padEnd(10))} ${file}`;
     });
   } catch {
     return [];
@@ -1166,7 +1621,7 @@ function getUncommittedChanges(repoPath) {
 }
 function getLastCommit(repoPath) {
   try {
-    return execSync5('git log -1 --pretty=format:"%h %s (%cr)"', {
+    return execSync6('git log -1 --pretty=format:"%h %s (%cr)"', {
       cwd: repoPath,
       encoding: "utf8",
       stdio: "pipe"
@@ -1177,64 +1632,64 @@ function getLastCommit(repoPath) {
 }
 function getRemoteStatus(repoPath) {
   try {
-    execSync5("git remote get-url origin", { cwd: repoPath, stdio: "pipe" });
+    execSync6("git remote get-url origin", { cwd: repoPath, stdio: "pipe" });
     try {
-      execSync5("git fetch", { cwd: repoPath, stdio: "pipe" });
+      execSync6("git fetch", { cwd: repoPath, stdio: "pipe" });
     } catch {
     }
-    const status = execSync5("git status -sb", {
+    const status = execSync6("git status -sb", {
       cwd: repoPath,
       encoding: "utf8",
       stdio: "pipe"
     });
     if (status.includes("ahead")) {
       const ahead = status.match(/ahead (\d+)/)?.[1] || "?";
-      return chalk5.yellow(`${ahead} commits ahead of remote`);
+      return chalk8.yellow(`${ahead} commits ahead of remote`);
     } else if (status.includes("behind")) {
       const behind = status.match(/behind (\d+)/)?.[1] || "?";
       try {
-        execSync5("git pull --rebase", {
+        execSync6("git pull --rebase", {
           stdio: "pipe",
           cwd: repoPath
         });
-        console.log(chalk5.green("\u2713 Automatically pulled latest changes"));
-        const newStatus = execSync5("git status -sb", {
+        console.log(chalk8.green("\u2713 Automatically pulled latest changes"));
+        const newStatus = execSync6("git status -sb", {
           encoding: "utf8",
           cwd: repoPath,
           stdio: "pipe"
         });
         if (newStatus.includes("behind")) {
           const newBehind = newStatus.match(/behind (\d+)/)?.[1] || "?";
-          return chalk5.yellow(`${newBehind} commits behind remote (after pull)`);
+          return chalk8.yellow(`${newBehind} commits behind remote (after pull)`);
         } else {
-          return chalk5.green("Up to date with remote (after pull)");
+          return chalk8.green("Up to date with remote (after pull)");
         }
       } catch {
-        return chalk5.yellow(`${behind} commits behind remote`);
+        return chalk8.yellow(`${behind} commits behind remote`);
       }
     } else {
-      return chalk5.green("Up to date with remote");
+      return chalk8.green("Up to date with remote");
     }
   } catch {
-    return chalk5.gray("No remote configured");
+    return chalk8.gray("No remote configured");
   }
 }
 async function thoughtsStatusCommand(options) {
   try {
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk5.red('Error: Thoughts not configured. Run "thoughtcabinet init" first.'));
+      console.error(chalk8.red('Error: Thoughts not configured. Run "thoughtcabinet init" first.'));
       process.exit(1);
     }
-    console.log(chalk5.blue("Thoughts Repository Status"));
-    console.log(chalk5.gray("=".repeat(50)));
+    console.log(chalk8.blue("Thoughts Repository Status"));
+    console.log(chalk8.gray("=".repeat(50)));
     console.log("");
-    console.log(chalk5.yellow("Configuration:"));
-    console.log(`  Repository: ${chalk5.cyan(config.thoughtsRepo)}`);
-    console.log(`  Repos directory: ${chalk5.cyan(config.reposDir)}`);
-    console.log(`  Global directory: ${chalk5.cyan(config.globalDir)}`);
-    console.log(`  User: ${chalk5.cyan(config.user)}`);
-    console.log(`  Mapped repos: ${chalk5.cyan(Object.keys(config.repoMappings).length)}`);
+    console.log(chalk8.yellow("Configuration:"));
+    console.log(`  Repository: ${chalk8.cyan(config.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk8.cyan(config.reposDir)}`);
+    console.log(`  Global directory: ${chalk8.cyan(config.globalDir)}`);
+    console.log(`  User: ${chalk8.cyan(config.user)}`);
+    console.log(`  Mapped repos: ${chalk8.cyan(Object.keys(config.repoMappings).length)}`);
     console.log("");
     const currentRepo = getCurrentRepoPath();
     const currentMapping = config.repoMappings[currentRepo];
@@ -1242,28 +1697,28 @@ async function thoughtsStatusCommand(options) {
     const profileName = getProfileNameFromMapping(currentMapping);
     const profileConfig = resolveProfileForRepo(config, currentRepo);
     if (mappedName) {
-      console.log(chalk5.yellow("Current Repository:"));
-      console.log(`  Path: ${chalk5.cyan(currentRepo)}`);
-      console.log(`  Thoughts directory: ${chalk5.cyan(`${profileConfig.reposDir}/${mappedName}`)}`);
+      console.log(chalk8.yellow("Current Repository:"));
+      console.log(`  Path: ${chalk8.cyan(currentRepo)}`);
+      console.log(`  Thoughts directory: ${chalk8.cyan(`${profileConfig.reposDir}/${mappedName}`)}`);
       if (profileName) {
-        console.log(`  Profile: ${chalk5.cyan(profileName)}`);
+        console.log(`  Profile: ${chalk8.cyan(profileName)}`);
       } else {
-        console.log(`  Profile: ${chalk5.gray("(default)")}`);
+        console.log(`  Profile: ${chalk8.gray("(default)")}`);
       }
-      const thoughtsDir = path9.join(currentRepo, "thoughts");
-      if (fs7.existsSync(thoughtsDir)) {
-        console.log(`  Status: ${chalk5.green("\u2713 Initialized")}`);
+      const thoughtsDir = path13.join(currentRepo, "thoughts");
+      if (fs10.existsSync(thoughtsDir)) {
+        console.log(`  Status: ${chalk8.green("\u2713 Initialized")}`);
       } else {
-        console.log(`  Status: ${chalk5.red("\u2717 Not initialized")}`);
+        console.log(`  Status: ${chalk8.red("\u2717 Not initialized")}`);
       }
     } else {
-      console.log(chalk5.yellow("Current repository not mapped to thoughts"));
+      console.log(chalk8.yellow("Current repository not mapped to thoughts"));
     }
     console.log("");
     const expandedRepo = expandPath(profileConfig.thoughtsRepo);
-    console.log(chalk5.yellow("Thoughts Repository Git Status:"));
+    console.log(chalk8.yellow("Thoughts Repository Git Status:"));
     if (profileName) {
-      console.log(chalk5.gray(`  (using profile: ${profileName})`));
+      console.log(chalk8.gray(`  (using profile: ${profileName})`));
     }
     console.log(`  ${getGitStatus(expandedRepo)}`);
     console.log(`  Remote: ${getRemoteStatus(expandedRepo)}`);
@@ -1271,33 +1726,33 @@ async function thoughtsStatusCommand(options) {
     console.log("");
     const changes = getUncommittedChanges(expandedRepo);
     if (changes.length > 0) {
-      console.log(chalk5.yellow("Uncommitted changes:"));
+      console.log(chalk8.yellow("Uncommitted changes:"));
       changes.forEach((change) => console.log(change));
       console.log("");
-      console.log(chalk5.gray('Run "thoughtcabinet sync" to commit these changes'));
+      console.log(chalk8.gray('Run "thoughtcabinet sync" to commit these changes'));
     } else {
-      console.log(chalk5.green("\u2713 No uncommitted changes"));
+      console.log(chalk8.green("\u2713 No uncommitted changes"));
     }
   } catch (error) {
-    console.error(chalk5.red(`Error checking thoughts status: ${error}`));
+    console.error(chalk8.red(`Error checking thoughts status: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/config.ts
-import { spawn } from "child_process";
-import chalk6 from "chalk";
+import { spawn as spawn2 } from "child_process";
+import chalk9 from "chalk";
 async function thoughtsConfigCommand(options) {
   try {
     const configPath = options.configFile || getDefaultConfigPath();
     if (options.edit) {
       const editor = process.env.EDITOR || "vi";
-      spawn(editor, [configPath], { stdio: "inherit" });
+      spawn2(editor, [configPath], { stdio: "inherit" });
       return;
     }
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk6.red("No thoughts configuration found."));
+      console.error(chalk9.red("No thoughts configuration found."));
       console.error('Run "thoughtcabinet init" to create one.');
       process.exit(1);
     }
@@ -1305,52 +1760,113 @@ async function thoughtsConfigCommand(options) {
       console.log(JSON.stringify(config, null, 2));
       return;
     }
-    console.log(chalk6.blue("Thoughts Configuration"));
-    console.log(chalk6.gray("=".repeat(50)));
+    console.log(chalk9.blue("Thoughts Configuration"));
+    console.log(chalk9.gray("=".repeat(50)));
     console.log("");
-    console.log(chalk6.yellow("Settings:"));
-    console.log(`  Config file: ${chalk6.cyan(configPath)}`);
-    console.log(`  Thoughts repository: ${chalk6.cyan(config.thoughtsRepo)}`);
-    console.log(`  Repos directory: ${chalk6.cyan(config.reposDir)}`);
-    console.log(`  Global directory: ${chalk6.cyan(config.globalDir)}`);
-    console.log(`  User: ${chalk6.cyan(config.user)}`);
+    console.log(chalk9.yellow("Settings:"));
+    console.log(`  Config file: ${chalk9.cyan(configPath)}`);
+    console.log(`  Thoughts repository: ${chalk9.cyan(config.thoughtsRepo)}`);
+    console.log(`  Repos directory: ${chalk9.cyan(config.reposDir)}`);
+    console.log(`  Global directory: ${chalk9.cyan(config.globalDir)}`);
+    console.log(`  User: ${chalk9.cyan(config.user)}`);
     console.log("");
-    console.log(chalk6.yellow("Repository Mappings:"));
+    console.log(chalk9.yellow("Repository Mappings:"));
     const mappings = Object.entries(config.repoMappings);
     if (mappings.length === 0) {
-      console.log(chalk6.gray("  No repositories mapped yet"));
+      console.log(chalk9.gray("  No repositories mapped yet"));
     } else {
       mappings.forEach(([repo, mapping]) => {
         const repoName = getRepoNameFromMapping(mapping);
         const profileName = getProfileNameFromMapping(mapping);
-        console.log(`  ${chalk6.cyan(repo)}`);
-        console.log(`    \u2192 ${chalk6.green(`${config.reposDir}/${repoName}`)}`);
+        console.log(`  ${chalk9.cyan(repo)}`);
+        console.log(`    \u2192 ${chalk9.green(`${config.reposDir}/${repoName}`)}`);
         if (profileName) {
-          console.log(`    Profile: ${chalk6.yellow(profileName)}`);
+          console.log(`    Profile: ${chalk9.yellow(profileName)}`);
         } else {
-          console.log(`    Profile: ${chalk6.gray("(default)")}`);
+          console.log(`    Profile: ${chalk9.gray("(default)")}`);
         }
       });
     }
     console.log("");
-    console.log(chalk6.yellow("Profiles:"));
+    console.log(chalk9.yellow("Profiles:"));
     if (!config.profiles || Object.keys(config.profiles).length === 0) {
-      console.log(chalk6.gray("  No profiles configured"));
+      console.log(chalk9.gray("  No profiles configured"));
     } else {
       Object.keys(config.profiles).forEach((name) => {
-        console.log(`  ${chalk6.cyan(name)}`);
+        console.log(`  ${chalk9.cyan(name)}`);
       });
     }
     console.log("");
-    console.log(chalk6.gray("To edit configuration, run: thoughtcabinet config --edit"));
+    console.log(chalk9.gray("To edit configuration, run: thoughtcabinet config --edit"));
+  } catch (error) {
+    console.error(chalk9.red(`Error showing thoughts config: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/thoughts/prune.ts
+import fs11 from "fs";
+import chalk10 from "chalk";
+async function thoughtsPruneCommand(options) {
+  try {
+    const config = loadThoughtsConfig(options);
+    if (!config) {
+      console.error(chalk10.red("Error: Thoughts configuration not found."));
+      console.error('Run "thoughtcabinet init" to create one.');
+      process.exit(1);
+    }
+    const mappings = Object.entries(config.repoMappings);
+    if (mappings.length === 0) {
+      console.log(chalk10.gray("No repository mappings configured."));
+      return;
+    }
+    const staleEntries = [];
+    for (const [repoPath, mapping] of mappings) {
+      if (!fs11.existsSync(repoPath)) {
+        staleEntries.push({
+          repoPath,
+          mappedName: getRepoNameFromMapping(mapping),
+          profileName: getProfileNameFromMapping(mapping)
+        });
+      }
+    }
+    if (staleEntries.length === 0) {
+      console.log(chalk10.green("No stale repository mappings found."));
+      console.log(chalk10.gray(`All ${mappings.length} mapped repositories exist.`));
+      return;
+    }
+    console.log(chalk10.yellow(`Found ${staleEntries.length} stale repository mapping(s):`));
+    console.log("");
+    for (const entry of staleEntries) {
+      console.log(`  ${chalk10.red("\u2717")} ${chalk10.cyan(entry.repoPath)}`);
+      console.log(`    \u2192 ${chalk10.gray(entry.mappedName || "(unknown)")}`);
+      if (entry.profileName) {
+        console.log(`    Profile: ${chalk10.yellow(entry.profileName)}`);
+      }
+    }
+    console.log("");
+    if (options.apply) {
+      console.log(chalk10.blue("Removing stale entries from configuration..."));
+      for (const entry of staleEntries) {
+        delete config.repoMappings[entry.repoPath];
+      }
+      saveThoughtsConfig(config, options);
+      console.log(chalk10.green(`\u2705 Removed ${staleEntries.length} stale mapping(s).`));
+      console.log("");
+      console.log(chalk10.gray("Note: The thoughts content in your thoughts repository was not modified."));
+      console.log(chalk10.gray("Only the configuration entries pointing to non-existent directories were removed."));
+    } else {
+      console.log(chalk10.gray("This is a dry run. No changes were made."));
+      console.log(chalk10.gray("Run with --apply to remove these stale entries."));
+    }
   } catch (error) {
-    console.error(chalk6.red(`Error showing thoughts config: ${error}`));
+    console.error(chalk10.red(`Error during thoughts prune: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/profile/create.ts
-import chalk7 from "chalk";
+import chalk11 from "chalk";
 import * as p2 from "@clack/prompts";
 async function profileCreateCommand(profileName, options) {
   try {
@@ -1371,7 +1887,7 @@ async function profileCreateCommand(profileName, options) {
     if (sanitizedName !== profileName) {
       p2.log.warn(`Profile name sanitized: "${profileName}" \u2192 "${sanitizedName}"`);
     }
-    p2.intro(chalk7.blue(`Creating Profile: ${sanitizedName}`));
+    p2.intro(chalk11.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.");
@@ -1432,15 +1948,15 @@ async function profileCreateCommand(profileName, options) {
     ensureThoughtsRepoExists(profileConfig);
     p2.log.success(`Profile "${sanitizedName}" created successfully!`);
     p2.note(
-      `Name: ${chalk7.cyan(sanitizedName)}
-Thoughts repository: ${chalk7.cyan(thoughtsRepo)}
-Repos directory: ${chalk7.cyan(reposDir)}
-Global directory: ${chalk7.cyan(globalDir)}`,
+      `Name: ${chalk11.cyan(sanitizedName)}
+Thoughts repository: ${chalk11.cyan(thoughtsRepo)}
+Repos directory: ${chalk11.cyan(reposDir)}
+Global directory: ${chalk11.cyan(globalDir)}`,
       "Profile Configuration"
     );
     p2.outro(
-      chalk7.gray("Next steps:\n") + chalk7.gray(`  1. Run "thoughtcabinet init --profile ${sanitizedName}" in a repository
-`) + chalk7.gray(`  2. Your thoughts will sync to the profile's repository`)
+      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`)
     );
   } catch (error) {
     p2.log.error(`Error creating profile: ${error}`);
@@ -1449,35 +1965,35 @@ Global directory: ${chalk7.cyan(globalDir)}`,
 }
 
 // src/commands/thoughts/profile/list.ts
-import chalk8 from "chalk";
+import chalk12 from "chalk";
 async function profileListCommand(options) {
   try {
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk8.red("Error: Thoughts not configured."));
+      console.error(chalk12.red("Error: Thoughts not configured."));
       process.exit(1);
     }
     if (options.json) {
       console.log(JSON.stringify(config.profiles || {}, null, 2));
       return;
     }
-    console.log(chalk8.blue("Thoughts Profiles"));
-    console.log(chalk8.gray("=".repeat(50)));
+    console.log(chalk12.blue("Thoughts Profiles"));
+    console.log(chalk12.gray("=".repeat(50)));
     console.log("");
-    console.log(chalk8.yellow("Default Configuration:"));
-    console.log(`  Thoughts repository: ${chalk8.cyan(config.thoughtsRepo)}`);
-    console.log(`  Repos directory: ${chalk8.cyan(config.reposDir)}`);
-    console.log(`  Global directory: ${chalk8.cyan(config.globalDir)}`);
+    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("");
     if (!config.profiles || Object.keys(config.profiles).length === 0) {
-      console.log(chalk8.gray("No profiles configured."));
+      console.log(chalk12.gray("No profiles configured."));
       console.log("");
-      console.log(chalk8.gray("Create a profile with: thoughtcabinet profile create <name>"));
+      console.log(chalk12.gray("Create a profile with: thoughtcabinet profile create <name>"));
     } else {
-      console.log(chalk8.yellow(`Profiles (${Object.keys(config.profiles).length}):`));
+      console.log(chalk12.yellow(`Profiles (${Object.keys(config.profiles).length}):`));
       console.log("");
       Object.entries(config.profiles).forEach(([name, profile]) => {
-        console.log(chalk8.cyan(`  ${name}:`));
+        console.log(chalk12.cyan(`  ${name}:`));
         console.log(`    Thoughts repository: ${profile.thoughtsRepo}`);
         console.log(`    Repos directory: ${profile.reposDir}`);
         console.log(`    Global directory: ${profile.globalDir}`);
@@ -1485,30 +2001,30 @@ async function profileListCommand(options) {
       });
     }
   } catch (error) {
-    console.error(chalk8.red(`Error listing profiles: ${error}`));
+    console.error(chalk12.red(`Error listing profiles: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/profile/show.ts
-import chalk9 from "chalk";
+import chalk13 from "chalk";
 async function profileShowCommand(profileName, options) {
   try {
     const config = loadThoughtsConfig(options);
     if (!config) {
-      console.error(chalk9.red("Error: Thoughts not configured."));
+      console.error(chalk13.red("Error: Thoughts not configured."));
       process.exit(1);
     }
     if (!validateProfile(config, profileName)) {
-      console.error(chalk9.red(`Error: Profile "${profileName}" not found.`));
+      console.error(chalk13.red(`Error: Profile "${profileName}" not found.`));
       console.error("");
-      console.error(chalk9.gray("Available profiles:"));
+      console.error(chalk13.gray("Available profiles:"));
       if (config.profiles) {
         Object.keys(config.profiles).forEach((name) => {
-          console.error(chalk9.gray(`  - ${name}`));
+          console.error(chalk13.gray(`  - ${name}`));
         });
       } else {
-        console.error(chalk9.gray("  (none)"));
+        console.error(chalk13.gray("  (none)"));
       }
       process.exit(1);
     }
@@ -1517,13 +2033,13 @@ async function profileShowCommand(profileName, options) {
       console.log(JSON.stringify(profile, null, 2));
       return;
     }
-    console.log(chalk9.blue(`Profile: ${profileName}`));
-    console.log(chalk9.gray("=".repeat(50)));
+    console.log(chalk13.blue(`Profile: ${profileName}`));
+    console.log(chalk13.gray("=".repeat(50)));
     console.log("");
-    console.log(chalk9.yellow("Configuration:"));
-    console.log(`  Thoughts repository: ${chalk9.cyan(profile.thoughtsRepo)}`);
-    console.log(`  Repos directory: ${chalk9.cyan(profile.reposDir)}`);
-    console.log(`  Global directory: ${chalk9.cyan(profile.globalDir)}`);
+    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("");
     let repoCount = 0;
     Object.values(config.repoMappings).forEach((mapping) => {
@@ -1531,16 +2047,16 @@ async function profileShowCommand(profileName, options) {
         repoCount++;
       }
     });
-    console.log(chalk9.yellow("Usage:"));
-    console.log(`  Repositories using this profile: ${chalk9.cyan(repoCount)}`);
+    console.log(chalk13.yellow("Usage:"));
+    console.log(`  Repositories using this profile: ${chalk13.cyan(repoCount)}`);
   } catch (error) {
-    console.error(chalk9.red(`Error showing profile: ${error}`));
+    console.error(chalk13.red(`Error showing profile: ${error}`));
     process.exit(1);
   }
 }
 
 // src/commands/thoughts/profile/delete.ts
-import chalk10 from "chalk";
+import chalk14 from "chalk";
 import * as p3 from "@clack/prompts";
 async function profileDeleteCommand(profileName, options) {
   try {
@@ -1549,7 +2065,7 @@ async function profileDeleteCommand(profileName, options) {
       p3.log.info("Use --force flag to delete without confirmation.");
       process.exit(1);
     }
-    p3.intro(chalk10.blue(`Delete Profile: ${profileName}`));
+    p3.intro(chalk14.blue(`Delete Profile: ${profileName}`));
     const config = loadThoughtsConfig(options);
     if (!config) {
       p3.log.error("Thoughts not configured.");
@@ -1568,19 +2084,19 @@ async function profileDeleteCommand(profileName, options) {
     if (usingRepos.length > 0 && !options.force) {
       p3.log.error(`Profile "${profileName}" is in use by ${usingRepos.length} repository(ies):`);
       usingRepos.forEach((repo) => {
-        p3.log.message(chalk10.gray(`  - ${repo}`));
+        p3.log.message(chalk14.gray(`  - ${repo}`));
       });
       p3.log.warn("Options:");
-      p3.log.message(chalk10.gray('  1. Run "thoughtcabinet destroy" in each repository'));
+      p3.log.message(chalk14.gray('  1. Run "thoughtcabinet destroy" in each repository'));
       p3.log.message(
-        chalk10.gray("  2. Use --force to delete anyway (repos will fall back to default config)")
+        chalk14.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: ${chalk10.cyan(profileName)}`);
-      p3.log.message(chalk10.gray("This will remove the profile configuration."));
-      p3.log.message(chalk10.gray("The thoughts repository files will NOT be deleted."));
+      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({
         message: `Delete profile "${profileName}"?`,
         initialValue: false
@@ -1599,7 +2115,7 @@ async function profileDeleteCommand(profileName, options) {
     if (usingRepos.length > 0) {
       p3.log.warn("Repositories using this profile will fall back to default config");
     }
-    p3.outro(chalk10.green("Done"));
+    p3.outro(chalk14.green("Done"));
   } catch (error) {
     p3.log.error(`Error deleting profile: ${error}`);
     process.exit(1);
@@ -1617,6 +2133,7 @@ function thoughtsCommand(program2) {
   cmd.command("sync").description("Manually sync thoughts to thoughts repository").option("-m, --message <message>", "Commit message for sync").option("--config-file <path>", "Path to config file").action(thoughtsSyncCommand);
   cmd.command("status").description("Show status of thoughts repository").option("--config-file <path>", "Path to config file").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);
   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);
@@ -1625,38 +2142,38 @@ function thoughtsCommand(program2) {
 }
 
 // src/commands/agent/init.ts
-import fs8 from "fs";
-import path10 from "path";
-import chalk11 from "chalk";
+import fs12 from "fs";
+import path14 from "path";
+import chalk15 from "chalk";
 import * as p4 from "@clack/prompts";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
 function ensureGitignoreEntry(targetDir, entry, productName) {
-  const gitignorePath = path10.join(targetDir, ".gitignore");
+  const gitignorePath = path14.join(targetDir, ".gitignore");
   let gitignoreContent = "";
-  if (fs8.existsSync(gitignorePath)) {
-    gitignoreContent = fs8.readFileSync(gitignorePath, "utf8");
+  if (fs12.existsSync(gitignorePath)) {
+    gitignoreContent = fs12.readFileSync(gitignorePath, "utf8");
   }
   const lines = gitignoreContent.split("\n");
   if (lines.some((line) => line.trim() === entry)) {
     return;
   }
   const newContent = gitignoreContent + (gitignoreContent && !gitignoreContent.endsWith("\n") ? "\n" : "") + "\n# " + productName + " local settings\n" + entry + "\n";
-  fs8.writeFileSync(gitignorePath, newContent);
+  fs12.writeFileSync(gitignorePath, newContent);
 }
 function copyDirectoryRecursive(sourceDir, targetDir) {
   let filesCopied = 0;
-  fs8.mkdirSync(targetDir, { recursive: true });
-  const entries = fs8.readdirSync(sourceDir, { withFileTypes: true });
+  fs12.mkdirSync(targetDir, { recursive: true });
+  const entries = fs12.readdirSync(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = path10.join(sourceDir, entry.name);
-    const targetPath = path10.join(targetDir, entry.name);
+    const sourcePath = path14.join(sourceDir, entry.name);
+    const targetPath = path14.join(targetDir, entry.name);
     if (entry.isDirectory()) {
       filesCopied += copyDirectoryRecursive(sourcePath, targetPath);
     } else {
-      fs8.copyFileSync(sourcePath, targetPath);
+      fs12.copyFileSync(sourcePath, targetPath);
       filesCopied++;
     }
   }
@@ -1665,23 +2182,23 @@ function copyDirectoryRecursive(sourceDir, targetDir) {
 async function agentInitCommand(options) {
   const { product } = options;
   try {
-    p4.intro(chalk11.blue(`Initialize ${product.name} Configuration`));
+    p4.intro(chalk15.blue(`Initialize ${product.name} Configuration`));
     if (!process.stdin.isTTY && !options.all) {
       p4.log.error("Not running in interactive terminal.");
       p4.log.info("Use --all flag to copy all files without prompting.");
       process.exit(1);
     }
     const targetDir = process.cwd();
-    const agentTargetDir = path10.join(targetDir, product.dirName);
+    const agentTargetDir = path14.join(targetDir, product.dirName);
     const possiblePaths = [
       // When installed via npm: package root is one level up from dist
-      path10.resolve(__dirname2, "..", product.sourceDirName),
+      path14.resolve(__dirname2, "..", product.sourceDirName),
       // When running from repo: repo root is two levels up from dist
-      path10.resolve(__dirname2, "../..", product.sourceDirName)
+      path14.resolve(__dirname2, "../..", product.sourceDirName)
     ];
     let sourceAgentDir = null;
     for (const candidatePath of possiblePaths) {
-      if (fs8.existsSync(candidatePath)) {
+      if (fs12.existsSync(candidatePath)) {
         sourceAgentDir = candidatePath;
         break;
       }
@@ -1695,7 +2212,7 @@ async function agentInitCommand(options) {
       p4.log.info("Are you running from the thoughtcabinet repository or npm package?");
       process.exit(1);
     }
-    if (fs8.existsSync(agentTargetDir) && !options.force) {
+    if (fs12.existsSync(agentTargetDir) && !options.force) {
       const overwrite = await p4.confirm({
         message: `${product.dirName} directory already exists. Overwrite?`,
         initialValue: false
@@ -1711,18 +2228,18 @@ async function agentInitCommand(options) {
     } else {
       let commandsCount = 0;
       let agentsCount = 0;
-      const commandsDir = path10.join(sourceAgentDir, "commands");
-      const agentsDir = path10.join(sourceAgentDir, "agents");
-      if (fs8.existsSync(commandsDir)) {
-        commandsCount = fs8.readdirSync(commandsDir).length;
+      const commandsDir = path14.join(sourceAgentDir, "commands");
+      const agentsDir = path14.join(sourceAgentDir, "agents");
+      if (fs12.existsSync(commandsDir)) {
+        commandsCount = fs12.readdirSync(commandsDir).length;
       }
-      if (fs8.existsSync(agentsDir)) {
-        agentsCount = fs8.readdirSync(agentsDir).length;
+      if (fs12.existsSync(agentsDir)) {
+        agentsCount = fs12.readdirSync(agentsDir).length;
       }
       let skillsCount = 0;
-      const skillsDir = path10.join(sourceAgentDir, "skills");
-      if (fs8.existsSync(skillsDir)) {
-        skillsCount = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).length;
+      const skillsDir = path14.join(sourceAgentDir, "skills");
+      if (fs12.existsSync(skillsDir)) {
+        skillsCount = fs12.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).length;
       }
       p4.note(
         "Use \u2191/\u2193 to move, press Space to select/deselect, press A to select/deselect all, press Enter to confirm. (Subsequent multi-selects apply; Ctrl+C to exit)",
@@ -1765,15 +2282,15 @@ async function agentInitCommand(options) {
         process.exit(0);
       }
     }
-    fs8.mkdirSync(agentTargetDir, { recursive: true });
+    fs12.mkdirSync(agentTargetDir, { recursive: true });
     let filesCopied = 0;
     let filesSkipped = 0;
     const filesToCopyByCategory = {};
     if (!options.all) {
       if (selectedCategories.includes("commands")) {
-        const sourceDir = path10.join(sourceAgentDir, "commands");
-        if (fs8.existsSync(sourceDir)) {
-          const allFiles = fs8.readdirSync(sourceDir);
+        const sourceDir = path14.join(sourceAgentDir, "commands");
+        if (fs12.existsSync(sourceDir)) {
+          const allFiles = fs12.readdirSync(sourceDir);
           const fileSelection = await p4.multiselect({
             message: "Select command files to copy:",
             options: allFiles.map((file) => ({
@@ -1794,9 +2311,9 @@ async function agentInitCommand(options) {
         }
       }
       if (selectedCategories.includes("agents")) {
-        const sourceDir = path10.join(sourceAgentDir, "agents");
-        if (fs8.existsSync(sourceDir)) {
-          const allFiles = fs8.readdirSync(sourceDir);
+        const sourceDir = path14.join(sourceAgentDir, "agents");
+        if (fs12.existsSync(sourceDir)) {
+          const allFiles = fs12.readdirSync(sourceDir);
           const fileSelection = await p4.multiselect({
             message: "Select agent files to copy:",
             options: allFiles.map((file) => ({
@@ -1817,9 +2334,9 @@ async function agentInitCommand(options) {
         }
       }
       if (selectedCategories.includes("skills")) {
-        const sourceDir = path10.join(sourceAgentDir, "skills");
-        if (fs8.existsSync(sourceDir)) {
-          const allSkills = fs8.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        const sourceDir = path14.join(sourceAgentDir, "skills");
+        if (fs12.existsSync(sourceDir)) {
+          const allSkills = fs12.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           if (allSkills.length > 0) {
             const skillSelection = await p4.multiselect({
               message: "Select skills to copy:",
@@ -1866,13 +2383,13 @@ async function agentInitCommand(options) {
     }
     for (const category of selectedCategories) {
       if (category === "commands" || category === "agents") {
-        const sourceDir = path10.join(sourceAgentDir, category);
-        const targetCategoryDir = path10.join(agentTargetDir, category);
-        if (!fs8.existsSync(sourceDir)) {
+        const sourceDir = path14.join(sourceAgentDir, category);
+        const targetCategoryDir = path14.join(agentTargetDir, category);
+        if (!fs12.existsSync(sourceDir)) {
           p4.log.warn(`${category} directory not found in source, skipping`);
           continue;
         }
-        const allFiles = fs8.readdirSync(sourceDir);
+        const allFiles = fs12.readdirSync(sourceDir);
         let filesToCopy = allFiles;
         if (!options.all && filesToCopyByCategory[category]) {
           filesToCopy = filesToCopyByCategory[category];
@@ -1880,20 +2397,20 @@ async function agentInitCommand(options) {
         if (filesToCopy.length === 0) {
           continue;
         }
-        fs8.mkdirSync(targetCategoryDir, { recursive: true });
+        fs12.mkdirSync(targetCategoryDir, { recursive: true });
         for (const file of filesToCopy) {
-          const sourcePath = path10.join(sourceDir, file);
-          const targetPath = path10.join(targetCategoryDir, file);
-          fs8.copyFileSync(sourcePath, targetPath);
+          const sourcePath = path14.join(sourceDir, file);
+          const targetPath = path14.join(targetCategoryDir, file);
+          fs12.copyFileSync(sourcePath, targetPath);
           filesCopied++;
         }
         filesSkipped += allFiles.length - filesToCopy.length;
         p4.log.success(`Copied ${filesToCopy.length} ${category} file(s)`);
       } else if (category === "settings") {
-        const settingsPath = path10.join(sourceAgentDir, "settings.template.json");
-        const targetSettingsPath = path10.join(agentTargetDir, "settings.json");
-        if (fs8.existsSync(settingsPath)) {
-          const settingsContent = fs8.readFileSync(settingsPath, "utf8");
+        const settingsPath = path14.join(sourceAgentDir, "settings.template.json");
+        const targetSettingsPath = path14.join(agentTargetDir, "settings.json");
+        if (fs12.existsSync(settingsPath)) {
+          const settingsContent = fs12.readFileSync(settingsPath, "utf8");
           const settings = JSON.parse(settingsContent);
           if (maxThinkingTokens !== void 0) {
             if (!settings.env) {
@@ -1907,20 +2424,20 @@ async function agentInitCommand(options) {
           for (const [key, value] of Object.entries(product.defaultEnvVars)) {
             settings.env[key] = value;
           }
-          fs8.writeFileSync(targetSettingsPath, JSON.stringify(settings, null, 2) + "\n");
+          fs12.writeFileSync(targetSettingsPath, JSON.stringify(settings, null, 2) + "\n");
           filesCopied++;
           p4.log.success(`Copied settings.json (maxTokens: ${maxThinkingTokens})`);
         } else {
           p4.log.warn("settings.json not found in source, skipping");
         }
       } else if (category === "skills") {
-        const sourceDir = path10.join(sourceAgentDir, "skills");
-        const targetCategoryDir = path10.join(agentTargetDir, "skills");
-        if (!fs8.existsSync(sourceDir)) {
+        const sourceDir = path14.join(sourceAgentDir, "skills");
+        const targetCategoryDir = path14.join(agentTargetDir, "skills");
+        if (!fs12.existsSync(sourceDir)) {
           p4.log.warn("skills directory not found in source, skipping");
           continue;
         }
-        const allSkills = fs8.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        const allSkills = fs12.readdirSync(sourceDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
         let skillsToCopy = allSkills;
         if (!options.all && filesToCopyByCategory["skills"]) {
           skillsToCopy = filesToCopyByCategory["skills"];
@@ -1928,11 +2445,11 @@ async function agentInitCommand(options) {
         if (skillsToCopy.length === 0) {
           continue;
         }
-        fs8.mkdirSync(targetCategoryDir, { recursive: true });
+        fs12.mkdirSync(targetCategoryDir, { recursive: true });
         let skillFilesCopied = 0;
         for (const skill of skillsToCopy) {
-          const sourceSkillPath = path10.join(sourceDir, skill);
-          const targetSkillPath = path10.join(targetCategoryDir, skill);
+          const sourceSkillPath = path14.join(sourceDir, skill);
+          const targetSkillPath = path14.join(targetCategoryDir, skill);
           skillFilesCopied += copyDirectoryRecursive(sourceSkillPath, targetSkillPath);
         }
         filesCopied += skillFilesCopied;
@@ -1946,10 +2463,10 @@ async function agentInitCommand(options) {
     }
     let message = `Successfully copied ${filesCopied} file(s) to ${agentTargetDir}`;
     if (filesSkipped > 0) {
-      message += chalk11.gray(`
+      message += chalk15.gray(`
    Skipped ${filesSkipped} file(s)`);
     }
-    message += chalk11.gray(`
+    message += chalk15.gray(`
    You can now use these commands in ${product.name}.`);
     p4.outro(message);
   } catch (error) {
@@ -2009,27 +2526,27 @@ function agentCommand(program2) {
 }
 
 // src/commands/metadata/metadata.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 function getGitInfo() {
   try {
-    execSync6("git rev-parse --is-inside-work-tree", {
+    execSync7("git rev-parse --is-inside-work-tree", {
       encoding: "utf8",
       stdio: "pipe"
     });
-    const repoRoot = execSync6("git rev-parse --show-toplevel", {
+    const repoRoot = execSync7("git rev-parse --show-toplevel", {
       encoding: "utf8",
       stdio: "pipe"
     }).trim();
     const repoName = repoRoot.split("/").pop() || "";
     let branch = "";
     try {
-      branch = execSync6("git branch --show-current", {
+      branch = execSync7("git branch --show-current", {
         encoding: "utf8",
         stdio: "pipe"
       }).trim();
     } catch {
       try {
-        branch = execSync6("git rev-parse --abbrev-ref HEAD", {
+        branch = execSync7("git rev-parse --abbrev-ref HEAD", {
           encoding: "utf8",
           stdio: "pipe"
         }).trim();
@@ -2039,7 +2556,7 @@ function getGitInfo() {
     }
     let commit = "";
     try {
-      commit = execSync6("git rev-parse HEAD", {
+      commit = execSync7("git rev-parse HEAD", {
         encoding: "utf8",
         stdio: "pipe"
       }).trim();
@@ -2095,6 +2612,460 @@ function metadataCommand(program2) {
   program2.command("metadata").description("Output metadata for current repository (branch, commit, timestamp, etc.)").action(specMetadataCommand);
 }
 
+// src/commands/worktree.ts
+import fs14 from "fs";
+import path16 from "path";
+import chalk16 from "chalk";
+
+// src/tmux.ts
+import { execFileSync as execFileSync3 } from "child_process";
+function sessionNameForHandle(handle) {
+  return `thc-${handle}`;
+}
+function legacySessionNameForHandle(handle) {
+  return `thc:${handle}`;
+}
+function allSessionNamesForHandle(handle) {
+  return [sessionNameForHandle(handle), legacySessionNameForHandle(handle)];
+}
+function listTmuxSessions() {
+  try {
+    const out = execFileSync3("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    return out.split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function tmuxHasSession(sessionName) {
+  try {
+    execFileSync3("tmux", ["has-session", "-t", sessionName], {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tmuxNewSession(sessionName, cwd) {
+  execFileSync3("tmux", ["new-session", "-d", "-s", sessionName, "-c", cwd], {
+    stdio: "inherit"
+  });
+}
+function tmuxKillSession(sessionName) {
+  try {
+    execFileSync3("tmux", ["kill-session", "-t", sessionName], { stdio: "ignore" });
+  } catch {
+  }
+}
+
+// src/agent-config.ts
+import fs13 from "fs";
+import path15 from "path";
+var AGENT_CONFIG_DIRS = [".claude", ".codebuddy"];
+function copyAgentConfigDirs(options) {
+  const { sourceDir, targetDir, configDirs = AGENT_CONFIG_DIRS } = options;
+  const copied = [];
+  const skipped = [];
+  for (const dirName of configDirs) {
+    const sourcePath = path15.join(sourceDir, dirName);
+    const targetPath = path15.join(targetDir, dirName);
+    if (!fs13.existsSync(sourcePath)) {
+      skipped.push(dirName);
+      continue;
+    }
+    fs13.cpSync(sourcePath, targetPath, { recursive: true });
+    copied.push(dirName);
+  }
+  return { copied, skipped };
+}
+
+// src/commands/worktree.ts
+function worktreeCommand(program2) {
+  const wt = program2.command("worktree").description("Manage git worktrees bound to tmux sessions");
+  wt.command("add <name>").description("Create a git worktree and a tmux session for it").option("--branch <branch>", "Branch name (defaults to <name>)").option("--base <ref>", "Base ref/commit (default: HEAD)", "HEAD").option("--path <path>", "Worktree directory path (default: ../<repo>__worktrees/<name>)").option("--detached", "Create a detached worktree at <base> (no branch)").option("--no-thoughts", "Skip thoughts initialization").action(async (name, options) => {
+    try {
+      validateWorktreeHandle(name);
+      if (!isGitRepo()) {
+        console.error(chalk16.red("Error: not in a git repository"));
+        process.exit(1);
+      }
+      const mainRoot = getMainWorktreeRoot();
+      const baseDir = getWorktreesBaseDir(mainRoot);
+      const worktreePath = options.path ? path16.resolve(options.path) : path16.join(baseDir, name);
+      fs14.mkdirSync(path16.dirname(worktreePath), { recursive: true });
+      const sessionName = sessionNameForHandle(name);
+      const sessionCandidates = allSessionNamesForHandle(name);
+      const existing = sessionCandidates.find((s) => tmuxHasSession(s));
+      if (existing) {
+        console.error(chalk16.red(`Error: tmux session already exists: ${existing}`));
+        process.exit(1);
+      }
+      const hooksConfig = loadHooksConfig(mainRoot);
+      const preAddHooks = getHooksForEvent(hooksConfig, "PreWorktreeAdd");
+      if (preAddHooks.length > 0) {
+        const hookInput = {
+          hook_event_name: "PreWorktreeAdd",
+          cwd: mainRoot,
+          worktree_path: worktreePath,
+          worktree_name: name,
+          worktree_branch: options.detached ? "" : options.branch ?? name,
+          main_root: mainRoot,
+          session_name: sessionName,
+          base_ref: options.base
+        };
+        const hookEnv = {
+          THC_WORKTREE_PATH: worktreePath,
+          THC_WORKTREE_NAME: name,
+          THC_WORKTREE_BRANCH: hookInput.worktree_branch,
+          THC_MAIN_ROOT: mainRoot,
+          THC_SESSION_NAME: sessionName,
+          THC_BASE_REF: options.base
+        };
+        await executeHooks(preAddHooks, hookInput, hookEnv, true);
+      }
+      if (options.detached) {
+        runGitCommandOrThrow(["worktree", "add", "--detach", worktreePath, options.base], {
+          cwd: mainRoot
+        });
+      } else {
+        const branch = options.branch ?? name;
+        runGitCommandOrThrow(["worktree", "add", "-b", branch, worktreePath, options.base], {
+          cwd: mainRoot
+        });
+        setBranchBase(branch, options.base, worktreePath);
+      }
+      tmuxNewSession(sessionName, worktreePath);
+      const configResult = copyAgentConfigDirs({
+        sourceDir: mainRoot,
+        targetDir: worktreePath
+      });
+      if (configResult.copied.length > 0) {
+        console.log(chalk16.gray(`Copied config: ${configResult.copied.join(", ")}`));
+      }
+      if (options.thoughts !== false) {
+        const config = loadThoughtsConfig({});
+        if (config) {
+          const mainRepoMapping = config.repoMappings[mainRoot];
+          const mappedName = getRepoNameFromMapping(mainRepoMapping);
+          if (mappedName) {
+            config.repoMappings[worktreePath] = mainRepoMapping;
+            saveThoughtsConfig(config, {});
+            const profileConfig = resolveProfileForRepo(config, worktreePath);
+            createThoughtsDirectoryStructure(profileConfig, mappedName, config.user);
+            const result = setupThoughtsDirectory({
+              repoPath: worktreePath,
+              profileConfig,
+              mappedName,
+              user: config.user,
+              createSearchable: true,
+              setupHooks: true
+            });
+            console.log(chalk16.gray("Thoughts initialized"));
+            if (result.hooksUpdated.length > 0) {
+              console.log(chalk16.gray(`Updated git hooks: ${result.hooksUpdated.join(", ")}`));
+            }
+            if (pullThoughtsFromRemote(profileConfig.thoughtsRepo)) {
+              console.log(chalk16.gray("Pulled latest thoughts from remote"));
+            }
+          } else {
+            console.log(chalk16.yellow("Main repo not configured for thoughts, skipping"));
+          }
+        } else {
+          console.log(chalk16.yellow("Thoughts not configured globally, skipping"));
+        }
+      }
+      const postAddHooks = getHooksForEvent(hooksConfig, "PostWorktreeAdd");
+      if (postAddHooks.length > 0) {
+        const hookInput = {
+          hook_event_name: "PostWorktreeAdd",
+          cwd: worktreePath,
+          worktree_path: worktreePath,
+          worktree_name: name,
+          worktree_branch: options.detached ? "" : options.branch ?? name,
+          main_root: mainRoot,
+          session_name: sessionName
+        };
+        const hookEnv = {
+          THC_WORKTREE_PATH: worktreePath,
+          THC_WORKTREE_NAME: name,
+          THC_WORKTREE_BRANCH: hookInput.worktree_branch,
+          THC_MAIN_ROOT: mainRoot,
+          THC_SESSION_NAME: sessionName
+        };
+        await executeHooks(postAddHooks, hookInput, hookEnv, true);
+      }
+      console.log(chalk16.green("\n\u2713 Worktree created"));
+      console.log(chalk16.gray(`Path: ${worktreePath}`));
+      console.log(chalk16.gray(`Tmux session: ${sessionName}`));
+      console.log(chalk16.gray(`Attach: tmux attach -t ${sessionName}`));
+    } catch (error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  wt.command("list").description("List thc-managed worktrees and their tmux sessions").option("--all", "Show all git worktrees (not just ../<repo>__worktrees)").action(async (options) => {
+    try {
+      if (!isGitRepo()) {
+        console.error(chalk16.red("Error: not in a git repository"));
+        process.exit(1);
+      }
+      const mainRoot = getMainWorktreeRoot();
+      const baseDir = getWorktreesBaseDir(mainRoot);
+      const baseDirResolved = path16.resolve(baseDir);
+      const entries = parseWorktreeListPorcelain(
+        runGitCommand(["worktree", "list", "--porcelain"], { cwd: mainRoot })
+      );
+      const sessions = new Set(listTmuxSessions());
+      const filtered = options.all ? entries : entries.filter((e) => {
+        const p5 = path16.resolve(e.worktreePath);
+        return p5 === path16.resolve(mainRoot) || p5.startsWith(baseDirResolved + path16.sep);
+      });
+      if (filtered.length === 0) {
+        console.log(chalk16.gray("No worktrees found."));
+        return;
+      }
+      const cwd = process.cwd();
+      const rows = filtered.map((e) => {
+        const name = path16.basename(e.worktreePath);
+        const sessionName = allSessionNamesForHandle(name).find((s) => sessions.has(s)) ?? "-";
+        const isCurrent = path16.resolve(e.worktreePath) === path16.resolve(cwd);
+        return {
+          name: isCurrent ? `* ${name}` : `  ${name}`,
+          branch: e.branch,
+          tmux: sessionName,
+          path: e.worktreePath,
+          isCurrent
+        };
+      });
+      const colWidths = {
+        name: Math.max("NAME".length + 2, ...rows.map((r) => r.name.length)),
+        branch: Math.max("BRANCH".length, ...rows.map((r) => r.branch.length)),
+        tmux: Math.max("TMUX".length, ...rows.map((r) => r.tmux.length))
+      };
+      console.log(
+        chalk16.blue(
+          `${"  NAME".padEnd(colWidths.name)}  ${"BRANCH".padEnd(colWidths.branch)}  ${"TMUX".padEnd(colWidths.tmux)}  PATH`
+        )
+      );
+      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 ? chalk16.green(line) : line);
+      }
+    } catch (error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  wt.command("merge <name>").description(
+    "Rebase worktree branch onto target, ff-merge, then clean up worktree + tmux session"
+  ).option(
+    "--into <branch>",
+    "Target branch to merge into (default: current branch in main worktree)"
+  ).option("--force", "Force cleanup even if uncommitted changes exist").option("--keep-session", "Do not kill the tmux session").option("--keep-worktree", "Do not remove the git worktree").option("--keep-branch", "Do not delete the source branch").action(async (name, options) => {
+    try {
+      if (!isGitRepo()) {
+        console.error(chalk16.red("Error: not in a git repository"));
+        process.exit(1);
+      }
+      const mainRoot = getMainWorktreeRoot();
+      const mainRootResolved = path16.resolve(mainRoot);
+      const wtEntry = findWorktree(name, mainRoot);
+      const wtResolved = path16.resolve(wtEntry.worktreePath);
+      if (wtResolved === mainRootResolved) {
+        console.error(chalk16.red("Error: refusing to merge/remove the main worktree"));
+        process.exit(1);
+      }
+      if (wtEntry.detached || wtEntry.branch === "(detached)") {
+        console.error(chalk16.red("Error: cannot merge a detached worktree"));
+        process.exit(1);
+      }
+      const targetBranch = options.into ?? runGitCommand(["branch", "--show-current"], { cwd: mainRoot });
+      if (!targetBranch) {
+        console.error(chalk16.red("Error: could not determine target branch. Use --into <branch>."));
+        process.exit(1);
+      }
+      if (targetBranch === wtEntry.branch) {
+        console.error(chalk16.red("Error: source and target branch are the same"));
+        process.exit(1);
+      }
+      const mergeHooksConfig = loadHooksConfig(mainRoot);
+      const preMergeHooks = getHooksForEvent(mergeHooksConfig, "PreWorktreeMerge");
+      if (preMergeHooks.length > 0) {
+        const hookInput = {
+          hook_event_name: "PreWorktreeMerge",
+          cwd: mainRoot,
+          worktree_path: wtResolved,
+          worktree_name: name,
+          worktree_branch: wtEntry.branch,
+          target_branch: targetBranch,
+          main_root: mainRoot
+        };
+        const hookEnv = {
+          THC_WORKTREE_PATH: wtResolved,
+          THC_WORKTREE_NAME: name,
+          THC_WORKTREE_BRANCH: wtEntry.branch,
+          THC_TARGET_BRANCH: targetBranch,
+          THC_MAIN_ROOT: mainRoot
+        };
+        await executeHooks(preMergeHooks, hookInput, hookEnv, true);
+      }
+      const config = loadThoughtsConfig({});
+      if (config && config.repoMappings[wtResolved]) {
+        try {
+          console.log(chalk16.gray("Cleaning up thoughts directory..."));
+          const result = cleanupThoughtsDirectory({
+            repoPath: wtResolved,
+            config,
+            force: options.force,
+            verbose: false
+            // Suppress detailed output during merge
+          });
+          if (result.configRemoved) {
+            saveThoughtsConfig(config, {});
+          }
+          if (result.thoughtsRemoved) {
+            console.log(chalk16.gray("\u2713 Thoughts directory cleaned up"));
+          }
+        } catch (error) {
+          console.log(
+            chalk16.yellow(`Warning: Could not clean up thoughts: ${error.message}`)
+          );
+        }
+      }
+      if (!options.force && hasUncommittedChanges(wtEntry.worktreePath)) {
+        console.error(
+          chalk16.red(
+            "Error: worktree has uncommitted changes. Commit/stash first or use --force."
+          )
+        );
+        process.exit(1);
+      }
+      console.log(chalk16.blue(`Rebasing ${wtEntry.branch} onto ${targetBranch}...`));
+      runGitCommandOrThrow(["rebase", targetBranch], { cwd: wtEntry.worktreePath });
+      console.log(chalk16.blue(`Fast-forward merging into ${targetBranch}...`));
+      runGitCommandOrThrow(["switch", targetBranch], { cwd: mainRoot });
+      runGitCommandOrThrow(["merge", "--ff-only", wtEntry.branch], { cwd: mainRoot });
+      const handle = path16.basename(wtEntry.worktreePath);
+      const sessionNames = allSessionNamesForHandle(handle);
+      if (!options.keepSession) {
+        for (const s of sessionNames) {
+          tmuxKillSession(s);
+        }
+      }
+      if (!options.keepWorktree) {
+        const removeArgs = ["worktree", "remove"];
+        if (options.force) {
+          removeArgs.push("--force");
+        }
+        removeArgs.push(wtEntry.worktreePath);
+        runGitCommandOrThrow(removeArgs, { cwd: mainRoot });
+        try {
+          runGitCommandOrThrow(["worktree", "prune"], { cwd: mainRoot });
+        } catch {
+        }
+      }
+      if (!options.keepBranch) {
+        try {
+          runGitCommandOrThrow(["branch", "-d", wtEntry.branch], { cwd: mainRoot });
+        } catch {
+          if (options.force) {
+            runGitCommandOrThrow(["branch", "-D", wtEntry.branch], { cwd: mainRoot });
+          } else {
+            throw new Error(
+              `Failed to delete branch '${wtEntry.branch}'. Re-run with --force to delete it.`
+            );
+          }
+        }
+      }
+      const postMergeHooks = getHooksForEvent(mergeHooksConfig, "PostWorktreeMerge");
+      if (postMergeHooks.length > 0) {
+        const hookInput = {
+          hook_event_name: "PostWorktreeMerge",
+          cwd: mainRoot,
+          worktree_path: wtResolved,
+          worktree_name: name,
+          worktree_branch: wtEntry.branch,
+          target_branch: targetBranch,
+          main_root: mainRoot,
+          kept_session: options.keepSession || false,
+          kept_worktree: options.keepWorktree || false,
+          kept_branch: options.keepBranch || false
+        };
+        const hookEnv = {
+          THC_WORKTREE_PATH: wtResolved,
+          THC_WORKTREE_NAME: name,
+          THC_WORKTREE_BRANCH: wtEntry.branch,
+          THC_TARGET_BRANCH: targetBranch,
+          THC_MAIN_ROOT: mainRoot,
+          THC_KEPT_SESSION: options.keepSession ? "true" : "false",
+          THC_KEPT_WORKTREE: options.keepWorktree ? "true" : "false",
+          THC_KEPT_BRANCH: options.keepBranch ? "true" : "false"
+        };
+        await executeHooks(postMergeHooks, hookInput, hookEnv, true);
+      }
+      console.log(chalk16.green("\u2713 Merged and cleaned up"));
+    } catch (error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/hooks/init.ts
+import fs15 from "fs";
+import path17 from "path";
+import chalk17 from "chalk";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2 } from "path";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+async function hooksInitCommand() {
+  try {
+    const repoPath = process.cwd();
+    const configDir = path17.join(repoPath, HOOKS_CONFIG_DIR);
+    const configPath = path17.join(repoPath, HOOKS_CONFIG_FILE);
+    if (fs15.existsSync(configPath)) {
+      console.log(chalk17.yellow(`${HOOKS_CONFIG_FILE} already exists.`));
+      console.log(chalk17.gray(`Edit the file directly: ${configPath}`));
+      return;
+    }
+    const possiblePaths = [
+      // When running from built dist: one level up from dist/
+      path17.resolve(__dirname3, "..", ".thought-cabinet/hooks.example.json"),
+      // When installed via npm: one level up from dist/
+      path17.resolve(__dirname3, "../..", ".thought-cabinet/hooks.example.json")
+    ];
+    let examplePath = null;
+    for (const candidatePath of possiblePaths) {
+      if (fs15.existsSync(candidatePath)) {
+        examplePath = candidatePath;
+        break;
+      }
+    }
+    if (!examplePath) {
+      console.error(chalk17.red("Error: hooks.example.json not found in expected locations"));
+      console.log(chalk17.gray("Searched paths:"));
+      possiblePaths.forEach((p5) => console.log(chalk17.gray(`  - ${p5}`)));
+      process.exit(1);
+    }
+    fs15.mkdirSync(configDir, { recursive: true });
+    fs15.copyFileSync(examplePath, configPath);
+    console.log(chalk17.green(`Created ${HOOKS_CONFIG_FILE}`));
+  } catch (error) {
+    console.error(chalk17.red(`Error during hooks init: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/hooks.ts
+function hooksCommand(program2) {
+  const hooks = program2.command("hooks").description("Manage hook configuration");
+  hooks.command("init").description("Initialize hooks configuration in current repository").action(hooksInitCommand);
+}
+
 // src/index.ts
 import dotenv2 from "dotenv";
 import { createRequire } from "module";
@@ -2108,5 +3079,7 @@ program.name("thoughtcabinet").description(
 thoughtsCommand(program);
 agentCommand(program);
 metadataCommand(program);
+worktreeCommand(program);
+hooksCommand(program);
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map