thought-cabinet 0.1.1 → 0.1.3

package/dist/index.js

@@ -55,6 +55,10 @@ var _ConfigResolver = class _ConfigResolver {
 };
 _ConfigResolver.DEFAULT_CONFIG_FILE = "config.json";
 var ConfigResolver = _ConfigResolver;
+function loadConfigFile(configFile) {
+  const resolver = new ConfigResolver({ configFile });
+  return resolver.loadConfigFile(configFile);
+}
 function saveConfigFile(config, configFile) {
   const configPath = configFile || getDefaultConfigPath();
   console.log(chalk.yellow(`Writing config to ${configPath}`));
@@ -107,10 +111,10 @@ function isGitRepo(cwd) {
     return false;
   }
 }
-function getMainRepoPath() {
+function getMainRepoPath(cwd) {
   try {
-    const gitCommonDir = runGitCommand(["rev-parse", "--git-common-dir"]);
-    const gitDir = runGitCommand(["rev-parse", "--git-dir"]);
+    const gitCommonDir = runGitCommand(["rev-parse", "--git-common-dir"], { cwd });
+    const gitDir = runGitCommand(["rev-parse", "--git-dir"], { cwd });
     if (gitCommonDir !== gitDir && gitCommonDir !== ".git") {
       const mainRepoPath = path2.dirname(path2.resolve(gitCommonDir));
       return mainRepoPath;
@@ -182,9 +186,63 @@ function hasUncommittedChanges(repoPath) {
   const status = runGitCommand(["status", "--porcelain"], { cwd: repoPath });
   return status.trim().length > 0;
 }
+function hasUnmergedCommits(branch, targetBranch, cwd) {
+  try {
+    const count = runGitCommand(["rev-list", "--count", `${targetBranch}..${branch}`], { cwd });
+    return parseInt(count, 10) > 0;
+  } catch {
+    return true;
+  }
+}
+function branchExists(branch, cwd) {
+  try {
+    runGitCommand(["rev-parse", "--verify", branch], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDefaultBranch(cwd) {
+  try {
+    const remoteBranch = runGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd });
+    return remoteBranch.replace("refs/remotes/origin/", "");
+  } catch {
+  }
+  if (branchExists("main", cwd)) return "main";
+  if (branchExists("master", cwd)) return "master";
+  return "main";
+}
 function setBranchBase(branch, base, cwd) {
   runGitCommandOrThrow(["config", "--local", `branch.${branch}.thc-base`, base], { cwd });
 }
+function getCurrentBranch(cwd) {
+  try {
+    return runGitCommand(["branch", "--show-current"], { cwd });
+  } catch {
+    try {
+      return runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+    } catch {
+      return "";
+    }
+  }
+}
+function getCurrentCommit(cwd) {
+  try {
+    return runGitCommand(["rev-parse", "HEAD"], { cwd });
+  } catch {
+    return "";
+  }
+}
+function getWorktreeRoot(cwd) {
+  return runGitCommand(["rev-parse", "--show-toplevel"], { cwd });
+}
+function getRepoRoot(cwd) {
+  const mainRepoPath = getMainRepoPath(cwd);
+  if (mainRepoPath) {
+    return mainRepoPath;
+  }
+  return getWorktreeRoot(cwd);
+}
 
 // src/commands/thoughts/utils/paths.ts
 function getDefaultThoughtsRepo() {
@@ -2123,8 +2181,8 @@ async function profileDeleteCommand(profileName, options) {
 }
 
 // src/commands/thoughts.ts
-function thoughtsCommand(program2) {
-  const cmd = program2;
+function thoughtsCommand(program) {
+  const cmd = program;
   cmd.command("init").description("Initialize thoughts for current repository").option("--force", "Force reconfiguration even if already set up").option("--config-file <path>", "Path to config file").option(
     "--directory <name>",
     "Specify the repository directory name (skips interactive prompt)"
@@ -2513,8 +2571,8 @@ function getAgentProduct(id) {
 }
 
 // src/commands/agent.ts
-function agentCommand(program2) {
-  const agent = program2.command("agent").description("Manage coding agent configuration");
+function agentCommand(program) {
+  const agent = program.command("agent").description("Manage coding agent configuration");
   agent.command("init").description("Initialize coding agent configuration in current directory").option("--force", "Force overwrite of existing agent directory").option("--all", "Copy all files without prompting").option(
     "--max-thinking-tokens <number>",
     "Maximum thinking tokens (default: 32000)",
@@ -2526,43 +2584,16 @@ function agentCommand(program2) {
 }
 
 // src/commands/metadata/metadata.ts
-import { execSync as execSync7 } from "child_process";
+import path15 from "path";
 function getGitInfo() {
+  if (!isGitRepo()) {
+    return null;
+  }
   try {
-    execSync7("git rev-parse --is-inside-work-tree", {
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    const repoRoot = execSync7("git rev-parse --show-toplevel", {
-      encoding: "utf8",
-      stdio: "pipe"
-    }).trim();
-    const repoName = repoRoot.split("/").pop() || "";
-    let branch = "";
-    try {
-      branch = execSync7("git branch --show-current", {
-        encoding: "utf8",
-        stdio: "pipe"
-      }).trim();
-    } catch {
-      try {
-        branch = execSync7("git rev-parse --abbrev-ref HEAD", {
-          encoding: "utf8",
-          stdio: "pipe"
-        }).trim();
-      } catch {
-        branch = "";
-      }
-    }
-    let commit = "";
-    try {
-      commit = execSync7("git rev-parse HEAD", {
-        encoding: "utf8",
-        stdio: "pipe"
-      }).trim();
-    } catch {
-      commit = "";
-    }
+    const repoRoot = getRepoRoot();
+    const repoName = path15.basename(repoRoot);
+    const branch = getCurrentBranch();
+    const commit = getCurrentCommit();
     return { repoRoot, repoName, branch, commit };
   } catch {
     return null;
@@ -2608,13 +2639,13 @@ async function specMetadataCommand() {
 }
 
 // src/commands/metadata.ts
-function metadataCommand(program2) {
-  program2.command("metadata").description("Output metadata for current repository (branch, commit, timestamp, etc.)").action(specMetadataCommand);
+function metadataCommand(program) {
+  program.command("metadata").description("Output metadata for current repository (branch, commit, timestamp, etc.)").action(specMetadataCommand);
 }
 
-// src/commands/worktree.ts
+// src/commands/worktree/add.ts
 import fs14 from "fs";
-import path16 from "path";
+import path17 from "path";
 import chalk16 from "chalk";
 
 // src/tmux.ts
@@ -2663,15 +2694,15 @@ function tmuxKillSession(sessionName) {
 
 // src/agent-config.ts
 import fs13 from "fs";
-import path15 from "path";
+import path16 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);
+    const sourcePath = path16.join(sourceDir, dirName);
+    const targetPath = path16.join(targetDir, dirName);
     if (!fs13.existsSync(sourcePath)) {
       skipped.push(dirName);
       continue;
@@ -2682,342 +2713,485 @@ function copyAgentConfigDirs(options) {
   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 = {
+// src/commands/worktree/add.ts
+async function worktreeAddCommand(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 ? path17.resolve(options.path) : path17.join(baseDir, name);
+    const branch = options.detached ? "" : options.branch ?? name;
+    const sessionName = sessionNameForHandle(name);
+    fs14.mkdirSync(path17.dirname(worktreePath), { recursive: true });
+    const sessionCandidates = allSessionNamesForHandle(name);
+    const existingSession = sessionCandidates.find((s) => tmuxHasSession(s));
+    if (existingSession) {
+      console.error(chalk16.red(`Error: tmux session already exists: ${existingSession}`));
+      process.exit(1);
+    }
+    const hooksConfig = loadHooksConfig(mainRoot);
+    const preAddHooks = getHooksForEvent(hooksConfig, "PreWorktreeAdd");
+    if (preAddHooks.length > 0) {
+      const hookEnv = {
+        THC_WORKTREE_PATH: worktreePath,
+        THC_WORKTREE_NAME: name,
+        THC_WORKTREE_BRANCH: branch,
+        THC_MAIN_ROOT: mainRoot,
+        THC_SESSION_NAME: sessionName,
+        THC_BASE_REF: options.base
+      };
+      await executeHooks(
+        preAddHooks,
+        {
           hook_event_name: "PreWorktreeAdd",
           cwd: mainRoot,
           worktree_path: worktreePath,
           worktree_name: name,
-          worktree_branch: options.detached ? "" : options.branch ?? name,
+          worktree_branch: branch,
           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
+        },
+        hookEnv,
+        true
+      );
+    }
+    if (options.detached) {
+      runGitCommandOrThrow(["worktree", "add", "--detach", worktreePath, options.base], {
+        cwd: mainRoot
       });
-      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 = {
+    } else {
+      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) {
+      initializeWorktreeThoughts(mainRoot, worktreePath);
+    }
+    const postAddHooks = getHooksForEvent(hooksConfig, "PostWorktreeAdd");
+    if (postAddHooks.length > 0) {
+      const hookEnv = {
+        THC_WORKTREE_PATH: worktreePath,
+        THC_WORKTREE_NAME: name,
+        THC_WORKTREE_BRANCH: branch,
+        THC_MAIN_ROOT: mainRoot,
+        THC_SESSION_NAME: sessionName
+      };
+      await executeHooks(
+        postAddHooks,
+        {
           hook_event_name: "PostWorktreeAdd",
           cwd: worktreePath,
           worktree_path: worktreePath,
           worktree_name: name,
-          worktree_branch: options.detached ? "" : options.branch ?? name,
+          worktree_branch: branch,
           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);
+        },
+        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);
+  }
+}
+function initializeWorktreeThoughts(mainRoot, worktreePath) {
+  const config = loadThoughtsConfig({});
+  if (!config) {
+    console.log(chalk16.yellow("Thoughts not configured globally, skipping"));
+    return;
+  }
+  const mainRepoMapping = config.repoMappings[mainRoot];
+  const mappedName = getRepoNameFromMapping(mainRepoMapping);
+  if (!mappedName) {
+    console.log(chalk16.yellow("Main repo not configured for thoughts, skipping"));
+    return;
+  }
+  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
   });
-  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.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"));
+  }
+}
+
+// src/commands/worktree/list.ts
+import path18 from "path";
+import chalk17 from "chalk";
+async function worktreeListCommand(options) {
+  try {
+    if (!isGitRepo()) {
+      console.error(chalk17.red("Error: not in a git repository"));
+      process.exit(1);
+    }
+    const mainRoot = getMainWorktreeRoot();
+    const baseDir = path18.resolve(getWorktreesBaseDir(mainRoot));
+    const cwd = path18.resolve(process.cwd());
+    const entries = parseWorktreeListPorcelain(
+      runGitCommand(["worktree", "list", "--porcelain"], { cwd: mainRoot })
+    );
+    const sessions = new Set(listTmuxSessions());
+    const filtered = options.all ? entries : entries.filter((e) => {
+      const p5 = path18.resolve(e.worktreePath);
+      return p5 === path18.resolve(mainRoot) || p5.startsWith(baseDir + path18.sep);
+    });
+    if (filtered.length === 0) {
+      console.log(chalk17.gray("No worktrees found."));
+      return;
+    }
+    const rows = filtered.map((e) => {
+      const name = path18.basename(e.worktreePath);
+      const isCurrent = path18.resolve(e.worktreePath) === cwd;
+      return {
+        name: isCurrent ? `* ${name}` : `  ${name}`,
+        branch: e.branch,
+        tmux: allSessionNamesForHandle(name).find((s) => sessions.has(s)) ?? "-",
+        path: e.worktreePath,
+        isCurrent
       };
-      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}`));
+    });
+    const colWidths = {
+      name: Math.max("  NAME".length, ...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))
+    };
+    const header = `${"  NAME".padEnd(colWidths.name)}  ${"BRANCH".padEnd(colWidths.branch)}  ${"TMUX".padEnd(colWidths.tmux)}  PATH`;
+    console.log(chalk17.blue(header));
+    for (const row of rows) {
+      const line = `${row.name.padEnd(colWidths.name)}  ${row.branch.padEnd(colWidths.branch)}  ${row.tmux.padEnd(colWidths.tmux)}  ${row.path}`;
+      console.log(row.isCurrent ? chalk17.green(line) : line);
+    }
+  } catch (error) {
+    console.error(chalk17.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/worktree/merge.ts
+import path20 from "path";
+import chalk19 from "chalk";
+
+// src/commands/worktree/utils.ts
+import path19 from "path";
+import chalk18 from "chalk";
+function cleanupWorktreeThoughts(wtPath, options = {}) {
+  const config = loadThoughtsConfig({});
+  if (!config || !config.repoMappings[wtPath]) {
+    return;
+  }
+  try {
+    if (options.verbose) {
+      console.log(chalk18.gray("Cleaning up thoughts directory..."));
+    }
+    const result = cleanupThoughtsDirectory({
+      repoPath: wtPath,
+      config,
+      force: options.force,
+      verbose: false
+    });
+    if (result.configRemoved) {
+      saveThoughtsConfig(config, {});
+    }
+    if (result.thoughtsRemoved && options.verbose) {
+      console.log(chalk18.gray("\u2713 Thoughts directory cleaned up"));
+    }
+  } catch (error) {
+    if (options.verbose) {
+      console.log(chalk18.yellow(`Warning: Could not clean up thoughts: ${error.message}`));
+    }
+  }
+}
+function cleanupWorktreeTmuxSession(wtPath) {
+  const handle = path19.basename(wtPath);
+  const sessionNames = allSessionNamesForHandle(handle);
+  for (const s of sessionNames) {
+    tmuxKillSession(s);
+  }
+}
+function removeGitWorktree(wtPath, mainRoot, options = {}) {
+  const removeArgs = ["worktree", "remove"];
+  if (options.force) {
+    removeArgs.push("--force");
+  }
+  removeArgs.push(wtPath);
+  runGitCommandOrThrow(removeArgs, { cwd: mainRoot });
+  try {
+    runGitCommandOrThrow(["worktree", "prune"], { cwd: mainRoot });
+  } catch {
+  }
+}
+function deleteWorktreeBranch(branch, mainRoot, options = {}) {
+  try {
+    runGitCommandOrThrow(["branch", "-d", branch], { cwd: mainRoot });
+  } catch {
+    if (options.force) {
+      runGitCommandOrThrow(["branch", "-D", branch], { cwd: mainRoot });
+    } else {
+      throw new Error(`Failed to delete branch '${branch}'. Re-run with --force to force delete.`);
+    }
+  }
+}
+
+// src/commands/worktree/merge.ts
+async function worktreeMergeCommand(name, options) {
+  try {
+    if (!isGitRepo()) {
+      console.error(chalk19.red("Error: not in a git repository"));
       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 = {
+    const mainRoot = getMainWorktreeRoot();
+    const wtEntry = findWorktree(name, mainRoot);
+    const wtPath = path20.resolve(wtEntry.worktreePath);
+    if (wtPath === path20.resolve(mainRoot)) {
+      console.error(chalk19.red("Error: refusing to merge/remove the main worktree"));
+      process.exit(1);
+    }
+    if (wtEntry.detached || wtEntry.branch === "(detached)") {
+      console.error(chalk19.red("Error: cannot merge a detached worktree"));
+      process.exit(1);
+    }
+    const targetBranch = options.into ?? runGitCommand(["branch", "--show-current"], { cwd: mainRoot });
+    if (!targetBranch) {
+      console.error(chalk19.red("Error: could not determine target branch. Use --into <branch>."));
+      process.exit(1);
+    }
+    if (targetBranch === wtEntry.branch) {
+      console.error(chalk19.red("Error: source and target branch are the same"));
+      process.exit(1);
+    }
+    const hooksConfig = loadHooksConfig(mainRoot);
+    const preHooks = getHooksForEvent(hooksConfig, "PreWorktreeMerge");
+    if (preHooks.length > 0) {
+      const hookEnv = {
+        THC_WORKTREE_PATH: wtPath,
+        THC_WORKTREE_NAME: name,
+        THC_WORKTREE_BRANCH: wtEntry.branch,
+        THC_TARGET_BRANCH: targetBranch,
+        THC_MAIN_ROOT: mainRoot
+      };
+      await executeHooks(
+        preHooks,
+        {
           hook_event_name: "PreWorktreeMerge",
           cwd: mainRoot,
-          worktree_path: wtResolved,
+          worktree_path: wtPath,
           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)) {
+        },
+        hookEnv,
+        true
+      );
+    }
+    cleanupWorktreeThoughts(wtPath, { force: options.force, verbose: true });
+    if (!options.force && hasUncommittedChanges(wtEntry.worktreePath)) {
+      console.error(
+        chalk19.red("Error: worktree has uncommitted changes. Commit/stash first or use --force.")
+      );
+      process.exit(1);
+    }
+    console.log(chalk19.blue(`Rebasing ${wtEntry.branch} onto ${targetBranch}...`));
+    runGitCommandOrThrow(["rebase", targetBranch], { cwd: wtEntry.worktreePath });
+    console.log(chalk19.blue(`Fast-forward merging into ${targetBranch}...`));
+    runGitCommandOrThrow(["switch", targetBranch], { cwd: mainRoot });
+    runGitCommandOrThrow(["merge", "--ff-only", wtEntry.branch], { cwd: mainRoot });
+    if (!options.keepSession) {
+      cleanupWorktreeTmuxSession(wtPath);
+    }
+    if (!options.keepWorktree) {
+      removeGitWorktree(wtPath, mainRoot, { force: options.force });
+    }
+    if (!options.keepBranch) {
+      deleteWorktreeBranch(wtEntry.branch, mainRoot, { force: options.force });
+    }
+    const postHooks = getHooksForEvent(hooksConfig, "PostWorktreeMerge");
+    if (postHooks.length > 0) {
+      const hookEnv = {
+        THC_WORKTREE_PATH: wtPath,
+        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(
+        postHooks,
+        {
+          hook_event_name: "PostWorktreeMerge",
+          cwd: mainRoot,
+          worktree_path: wtPath,
+          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
+        },
+        hookEnv,
+        true
+      );
+    }
+    console.log(chalk19.green("\u2713 Merged and cleaned up"));
+  } catch (error) {
+    console.error(chalk19.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/worktree/remove.ts
+import path21 from "path";
+import chalk20 from "chalk";
+async function worktreeRemoveCommand(name, options) {
+  try {
+    if (!isGitRepo()) {
+      console.error(chalk20.red("Error: not in a git repository"));
+      process.exit(1);
+    }
+    const mainRoot = getMainWorktreeRoot();
+    const wtEntry = findWorktree(name, mainRoot);
+    const wtPath = path21.resolve(wtEntry.worktreePath);
+    const hasBranch = !wtEntry.detached && wtEntry.branch !== "(detached)";
+    if (wtPath === path21.resolve(mainRoot)) {
+      console.error(chalk20.red("Error: refusing to remove the main worktree"));
+      process.exit(1);
+    }
+    if (!options.force && hasBranch) {
+      const defaultBranch = getDefaultBranch(mainRoot);
+      if (hasUnmergedCommits(wtEntry.branch, defaultBranch, mainRoot)) {
         console.error(
-          chalk16.red(
-            "Error: worktree has uncommitted changes. Commit/stash first or use --force."
+          chalk20.red(
+            `Error: branch '${wtEntry.branch}' has commits not merged into '${defaultBranch}'. Merge first or use --force to discard.`
           )
         );
         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",
+    }
+    const hooksConfig = loadHooksConfig(mainRoot);
+    const preHooks = getHooksForEvent(hooksConfig, "PreWorktreeRemove");
+    if (preHooks.length > 0) {
+      const hookEnv = {
+        THC_WORKTREE_PATH: wtPath,
+        THC_WORKTREE_NAME: name,
+        THC_WORKTREE_BRANCH: wtEntry.branch,
+        THC_MAIN_ROOT: mainRoot
+      };
+      await executeHooks(
+        preHooks,
+        {
+          hook_event_name: "PreWorktreeRemove",
           cwd: mainRoot,
-          worktree_path: wtResolved,
+          worktree_path: wtPath,
           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}`));
+          main_root: mainRoot
+        },
+        hookEnv,
+        true
+      );
+    }
+    cleanupWorktreeThoughts(wtPath, { force: options.force, verbose: true });
+    if (!options.force && hasUncommittedChanges(wtEntry.worktreePath)) {
+      console.error(
+        chalk20.red("Error: worktree has uncommitted changes. Commit/stash first or use --force.")
+      );
       process.exit(1);
     }
-  });
+    cleanupWorktreeTmuxSession(wtPath);
+    console.log(chalk20.gray("Removing git worktree..."));
+    removeGitWorktree(wtPath, mainRoot, { force: options.force });
+    if (hasBranch) {
+      console.log(chalk20.gray(`Deleting branch '${wtEntry.branch}'...`));
+      try {
+        deleteWorktreeBranch(wtEntry.branch, mainRoot, { force: options.force });
+      } catch (error) {
+        console.log(chalk20.yellow(`Warning: ${error.message}`));
+      }
+    }
+    const postHooks = getHooksForEvent(hooksConfig, "PostWorktreeRemove");
+    if (postHooks.length > 0) {
+      const hookEnv = {
+        THC_WORKTREE_PATH: wtPath,
+        THC_WORKTREE_NAME: name,
+        THC_WORKTREE_BRANCH: wtEntry.branch,
+        THC_MAIN_ROOT: mainRoot
+      };
+      await executeHooks(
+        postHooks,
+        {
+          hook_event_name: "PostWorktreeRemove",
+          cwd: mainRoot,
+          worktree_path: wtPath,
+          worktree_name: name,
+          worktree_branch: wtEntry.branch,
+          main_root: mainRoot
+        },
+        hookEnv,
+        true
+      );
+    }
+    console.log(chalk20.green("\u2713 Worktree removed"));
+  } catch (error) {
+    console.error(chalk20.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/worktree.ts
+function worktreeCommand(program) {
+  const wt = program.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(worktreeAddCommand);
+  wt.command("list").description("List thc-managed worktrees and their tmux sessions").option("--all", "Show all git worktrees (not just ../<repo>__worktrees)").action(worktreeListCommand);
+  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(worktreeMergeCommand);
+  wt.command("remove <name>").description(
+    "Remove a worktree and clean up associated resources (tmux session, thoughts, branch)"
+  ).option("--force", "Force removal even with uncommitted changes or unmerged commits").action(worktreeRemoveCommand);
 }
 
 // src/commands/hooks/init.ts
 import fs15 from "fs";
-import path17 from "path";
-import chalk17 from "chalk";
+import path22 from "path";
+import chalk21 from "chalk";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2 } from "path";
 var __filename3 = fileURLToPath2(import.meta.url);
@@ -3025,18 +3199,18 @@ 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);
+    const configDir = path22.join(repoPath, HOOKS_CONFIG_DIR);
+    const configPath = path22.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}`));
+      console.log(chalk21.yellow(`${HOOKS_CONFIG_FILE} already exists.`));
+      console.log(chalk21.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"),
+      path22.resolve(__dirname3, "..", ".thought-cabinet/hooks.example.json"),
       // When installed via npm: one level up from dist/
-      path17.resolve(__dirname3, "../..", ".thought-cabinet/hooks.example.json")
+      path22.resolve(__dirname3, "../..", ".thought-cabinet/hooks.example.json")
     ];
     let examplePath = null;
     for (const candidatePath of possiblePaths) {
@@ -3046,40 +3220,217 @@ async function hooksInitCommand() {
       }
     }
     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}`)));
+      console.error(chalk21.red("Error: hooks.example.json not found in expected locations"));
+      console.log(chalk21.gray("Searched paths:"));
+      possiblePaths.forEach((p5) => console.log(chalk21.gray(`  - ${p5}`)));
       process.exit(1);
     }
     fs15.mkdirSync(configDir, { recursive: true });
     fs15.copyFileSync(examplePath, configPath);
-    console.log(chalk17.green(`Created ${HOOKS_CONFIG_FILE}`));
+    console.log(chalk21.green(`Created ${HOOKS_CONFIG_FILE}`));
   } catch (error) {
-    console.error(chalk17.red(`Error during hooks init: ${error}`));
+    console.error(chalk21.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");
+function hooksCommand(program) {
+  const hooks = program.command("hooks").description("Manage hook configuration");
   hooks.command("init").description("Initialize hooks configuration in current repository").action(hooksInitCommand);
 }
 
+// src/commands/completion.ts
+function completionCommand(program) {
+  const completion = program.command("completion").description("Manage shell completion for thoughtcabinet CLI");
+  completion.command("install").description("Install shell completion scripts").action(async () => {
+    const { install } = await import("./installer-LJ3SJXPW.js");
+    await install();
+  });
+  completion.command("uninstall").description("Remove shell completion scripts").action(async () => {
+    const { uninstall } = await import("./installer-LJ3SJXPW.js");
+    await uninstall();
+  });
+}
+
+// src/completion/handler.ts
+import tabtab from "tabtab";
+
+// src/completion/providers.ts
+import path23 from "path";
+function getProfileNames() {
+  try {
+    const config = loadConfigFile();
+    if (!config.thoughts?.profiles) {
+      return [];
+    }
+    return Object.keys(config.thoughts.profiles);
+  } catch {
+    return [];
+  }
+}
+function getWorktreeNames() {
+  try {
+    if (!isGitRepo()) {
+      return [];
+    }
+    const mainRoot = getMainWorktreeRoot();
+    const baseDir = getWorktreesBaseDir(mainRoot);
+    const output = runGitCommand(["worktree", "list", "--porcelain"]);
+    const entries = parseWorktreeListPorcelain(output);
+    return entries.filter((e) => {
+      const p5 = path23.resolve(e.worktreePath);
+      return p5.startsWith(baseDir + path23.sep);
+    }).map((e) => path23.basename(e.worktreePath));
+  } catch {
+    return [];
+  }
+}
+function getBranchNames() {
+  try {
+    if (!isGitRepo()) {
+      return [];
+    }
+    const output = runGitCommand(["branch", "--format=%(refname:short)"]);
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getAgentNames() {
+  return ["claude", "codebuddy"];
+}
+
+// src/completion/handler.ts
+var TOP_LEVEL_COMMANDS = [
+  "init",
+  "destroy",
+  "sync",
+  "status",
+  "config",
+  "prune",
+  "profile",
+  "worktree",
+  "agent",
+  "metadata",
+  "hooks",
+  "completion"
+];
+var SUBCOMMANDS = {
+  profile: ["create", "list", "show", "delete"],
+  worktree: ["add", "list", "merge", "remove"],
+  agent: ["init"],
+  hooks: ["init"],
+  completion: ["install", "uninstall"]
+};
+var OPTIONS = {
+  init: ["--force", "--config-file", "--directory", "--profile"],
+  destroy: ["--force", "--config-file"],
+  sync: ["-m", "--message", "--config-file"],
+  status: ["--config-file"],
+  config: ["--edit", "--json", "--config-file"],
+  prune: ["--apply", "--config-file"],
+  "profile create": ["--repo", "--repos-dir", "--global-dir", "--config-file"],
+  "profile list": ["--json", "--config-file"],
+  "profile show": ["--json", "--config-file"],
+  "profile delete": ["--force", "--config-file"],
+  "worktree add": ["--branch", "--base", "--path", "--detached", "--no-thoughts"],
+  "worktree list": ["--all"],
+  "worktree merge": ["--into", "--force", "--keep-session", "--keep-worktree", "--keep-branch"],
+  "worktree remove": ["--force"],
+  "agent init": ["--force", "--all", "--max-thinking-tokens", "--name"]
+};
+var DYNAMIC_ARGS = {
+  "profile show": getProfileNames,
+  "profile delete": getProfileNames,
+  "worktree merge": getWorktreeNames,
+  "worktree remove": getWorktreeNames
+};
+var DYNAMIC_OPTIONS = {
+  "--profile": getProfileNames,
+  "--branch": getBranchNames,
+  "--base": getBranchNames,
+  "--into": getBranchNames,
+  "--name": getAgentNames
+};
+async function handleCompletion() {
+  const env = tabtab.parseEnv(process.env);
+  if (!env.complete) {
+    return false;
+  }
+  const { line, prev } = env;
+  const args = line.split(" ").filter(Boolean).slice(1);
+  if (prev in DYNAMIC_OPTIONS) {
+    const provider = DYNAMIC_OPTIONS[prev];
+    await tabtab.log(provider());
+    return true;
+  }
+  if (args.length === 0 || args.length === 1 && !line.endsWith(" ")) {
+    const partial = args[0] || "";
+    const matches = TOP_LEVEL_COMMANDS.filter((cmd) => cmd.startsWith(partial));
+    await tabtab.log(matches);
+    return true;
+  }
+  const firstArg = args[0];
+  if (firstArg in SUBCOMMANDS) {
+    const subcommands = SUBCOMMANDS[firstArg];
+    if (args.length === 1 && line.endsWith(" ")) {
+      await tabtab.log(subcommands);
+      return true;
+    }
+    if (args.length === 2 && !line.endsWith(" ")) {
+      const partial = args[1];
+      const matches = subcommands.filter((sub) => sub.startsWith(partial));
+      await tabtab.log(matches);
+      return true;
+    }
+  }
+  const commandKey = args.slice(0, 2).join(" ");
+  if (commandKey in DYNAMIC_ARGS && args.length === 2 && line.endsWith(" ")) {
+    const provider = DYNAMIC_ARGS[commandKey];
+    await tabtab.log(provider());
+    return true;
+  }
+  if (prev.startsWith("-")) {
+    await tabtab.log([]);
+    return true;
+  }
+  const options = OPTIONS[commandKey] || OPTIONS[firstArg] || [];
+  if (line.endsWith(" ") || prev.startsWith("-")) {
+    const usedOptions = args.filter((arg) => arg.startsWith("-"));
+    const availableOptions = options.filter((opt) => !usedOptions.includes(opt));
+    await tabtab.log(availableOptions);
+    return true;
+  }
+  await tabtab.log([]);
+  return true;
+}
+
 // src/index.ts
 import dotenv2 from "dotenv";
 import { createRequire } from "module";
-dotenv2.config();
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
-var program = new Command();
-program.name("thoughtcabinet").description(
-  "Thought Cabinet (thc) \u2014 CLI for structured AI coding workflows with filesystem-based memory and context management."
-).version(version);
-thoughtsCommand(program);
-agentCommand(program);
-metadataCommand(program);
-worktreeCommand(program);
-hooksCommand(program);
-program.parse(process.argv);
+async function main() {
+  const completionHandled = await handleCompletion();
+  if (completionHandled) {
+    process.exit(0);
+  }
+  dotenv2.config();
+  const require2 = createRequire(import.meta.url);
+  const { version } = require2("../package.json");
+  const program = new Command();
+  program.name("thoughtcabinet").description(
+    "Thought Cabinet (thc) \u2014 CLI for structured AI coding workflows with filesystem-based memory and context management."
+  ).version(version);
+  thoughtsCommand(program);
+  agentCommand(program);
+  metadataCommand(program);
+  worktreeCommand(program);
+  hooksCommand(program);
+  completionCommand(program);
+  program.parse(process.argv);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
 //# sourceMappingURL=index.js.map