claude-threads 1.4.3 → 1.4.5

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.5] - 2026-01-18
+
+### Fixed
+- **Worktree switch with prompt** - `!worktree switch branch prompt text` now switches to existing worktree and starts session with the prompt (#242)
+
+## [1.4.4] - 2026-01-18
+
+### Fixed
+- **Worktree commands in root messages** - `!worktree list` now works without a session, `!worktree branch-name` now starts session without requiring additional prompt (#241)
+
 ## [1.4.3] - 2026-01-18
 
 ### Added

package/dist/index.js

@@ -8822,6 +8822,80 @@ var require_semver2 = __commonJS((exports, module) => {
   };
 });
 
+// src/utils/logger.ts
+function setLogHandler(handler) {
+  globalLogHandler = handler;
+}
+function createLogger(component, useStderr = false, sessionId) {
+  const isDebug = () => process.env.DEBUG === "1";
+  const consoleLog = useStderr ? console.error : console.log;
+  const paddedComponent = component.length > COMPONENT_WIDTH ? component.substring(0, COMPONENT_WIDTH) : component.padEnd(COMPONENT_WIDTH);
+  const formatMessage = (msg, args) => {
+    if (args.length === 0)
+      return msg;
+    return `${msg} ${args.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ")}`;
+  };
+  const DEFAULT_JSON_MAX_LEN = 60;
+  return {
+    debug: (msg, ...args) => {
+      if (isDebug()) {
+        const fullMsg = formatMessage(msg, args);
+        if (globalLogHandler) {
+          globalLogHandler("debug", paddedComponent, fullMsg, sessionId);
+        } else {
+          consoleLog(`[${paddedComponent}] ${fullMsg}`);
+        }
+      }
+    },
+    debugJson: (label, data, maxLen = DEFAULT_JSON_MAX_LEN) => {
+      if (isDebug()) {
+        const json2 = JSON.stringify(data);
+        const truncated = json2.length > maxLen ? `${json2.substring(0, maxLen)}…` : json2;
+        const fullMsg = `${label}: ${truncated}`;
+        if (globalLogHandler) {
+          globalLogHandler("debug", paddedComponent, fullMsg, sessionId);
+        } else {
+          consoleLog(`[${paddedComponent}] ${fullMsg}`);
+        }
+      }
+    },
+    info: (msg, ...args) => {
+      const fullMsg = formatMessage(msg, args);
+      if (globalLogHandler) {
+        globalLogHandler("info", paddedComponent, fullMsg, sessionId);
+      } else {
+        consoleLog(`[${paddedComponent}] ${fullMsg}`);
+      }
+    },
+    warn: (msg, ...args) => {
+      const fullMsg = formatMessage(msg, args);
+      if (globalLogHandler) {
+        globalLogHandler("warn", paddedComponent, fullMsg, sessionId);
+      } else {
+        console.warn(`[${paddedComponent}] ⚠️ ${fullMsg}`);
+      }
+    },
+    error: (msg, err) => {
+      const fullMsg = err && isDebug() ? `${msg}
+${err.stack || err.message}` : msg;
+      if (globalLogHandler) {
+        globalLogHandler("error", paddedComponent, fullMsg, sessionId);
+      } else {
+        console.error(`[${paddedComponent}] ❌ ${msg}`);
+        if (err && isDebug()) {
+          console.error(err);
+        }
+      }
+    },
+    forSession: (sid) => createLogger(component, useStderr, sid)
+  };
+}
+var globalLogHandler = null, COMPONENT_WIDTH = 10, mcpLogger, wsLogger;
+var init_logger = __esm(() => {
+  mcpLogger = createLogger("MCP", true);
+  wsLogger = createLogger("ws", false);
+});
+
 // src/utils/emoji.ts
 var exports_emoji = {};
 __export(exports_emoji, {
@@ -8892,6 +8966,334 @@ var init_emoji = __esm(() => {
   };
 });
 
+// src/git/worktree.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  writeWorktreeMetadata: () => writeWorktreeMetadata,
+  updateWorktreeActivity: () => updateWorktreeActivity,
+  removeWorktreeMetadata: () => removeWorktreeMetadata,
+  removeWorktree: () => removeWorktree,
+  readWorktreeMetadata: () => readWorktreeMetadata,
+  listWorktrees: () => listWorktrees,
+  isValidWorktreePath: () => isValidWorktreePath,
+  isValidBranchName: () => isValidBranchName,
+  isGitRepository: () => isGitRepository,
+  isBranchMerged: () => isBranchMerged,
+  hasUncommittedChanges: () => hasUncommittedChanges,
+  getWorktreesDir: () => getWorktreesDir,
+  getWorktreeDir: () => getWorktreeDir,
+  getRepositoryRoot: () => getRepositoryRoot,
+  getDefaultBranch: () => getDefaultBranch,
+  getCurrentBranch: () => getCurrentBranch,
+  findWorktreeByBranch: () => findWorktreeByBranch,
+  detectWorktreeInfo: () => detectWorktreeInfo,
+  createWorktree: () => createWorktree
+});
+import { spawn as spawn2 } from "child_process";
+import { randomUUID } from "crypto";
+import * as path from "path";
+import * as fs from "fs/promises";
+import { homedir as homedir4 } from "os";
+async function execGit(args, cwd) {
+  const cmd = `git ${args.join(" ")}`;
+  log7.debug(`Executing: ${cmd}`);
+  return new Promise((resolve3, reject) => {
+    const proc = spawn2("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        log7.debug(`${cmd} → success`);
+        resolve3(stdout.trim());
+      } else {
+        log7.debug(`${cmd} → failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
+        reject(new Error(`git ${args.join(" ")} failed: ${stderr || stdout}`));
+      }
+    });
+    proc.on("error", (err) => {
+      log7.warn(`${cmd} → error: ${err}`);
+      reject(err);
+    });
+  });
+}
+async function isGitRepository(dir) {
+  try {
+    await execGit(["rev-parse", "--git-dir"], dir);
+    return true;
+  } catch (err) {
+    log7.debug(`Not a git repository: ${dir} (${err})`);
+    return false;
+  }
+}
+async function getRepositoryRoot(dir) {
+  return execGit(["rev-parse", "--show-toplevel"], dir);
+}
+async function getCurrentBranch(dir) {
+  try {
+    const branch = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], dir);
+    return branch === "HEAD" ? null : branch;
+  } catch {
+    return null;
+  }
+}
+async function getDefaultBranch(repoRoot) {
+  try {
+    const remoteHead = await execGit(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoRoot);
+    return remoteHead.replace("origin/", "");
+  } catch {
+    try {
+      await execGit(["rev-parse", "--verify", "main"], repoRoot);
+      return "main";
+    } catch {
+      try {
+        await execGit(["rev-parse", "--verify", "master"], repoRoot);
+        return "master";
+      } catch {
+        return "main";
+      }
+    }
+  }
+}
+async function isBranchMerged(repoRoot, branchName) {
+  try {
+    const defaultBranch = await getDefaultBranch(repoRoot);
+    if (branchName === defaultBranch) {
+      return false;
+    }
+    await execGit(["fetch", "origin", defaultBranch], repoRoot).catch(() => {});
+    const branchCommit = await execGit(["rev-parse", branchName], repoRoot);
+    const defaultCommit = await execGit(["rev-parse", `origin/${defaultBranch}`], repoRoot);
+    if (branchCommit === defaultCommit) {
+      return false;
+    }
+    await execGit(["merge-base", "--is-ancestor", branchName, `origin/${defaultBranch}`], repoRoot);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasUncommittedChanges(dir) {
+  try {
+    const staged = await execGit(["diff", "--cached", "--quiet"], dir).catch(() => "changes");
+    if (staged === "changes")
+      return true;
+    const unstaged = await execGit(["diff", "--quiet"], dir).catch(() => "changes");
+    if (unstaged === "changes")
+      return true;
+    const untracked = await execGit(["ls-files", "--others", "--exclude-standard"], dir);
+    return untracked.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function listWorktrees(repoRoot) {
+  const output = await execGit(["worktree", "list", "--porcelain"], repoRoot);
+  const worktrees = [];
+  if (!output)
+    return worktrees;
+  const blocks = output.split(`
+
+`).filter(Boolean);
+  for (const block of blocks) {
+    const lines = block.split(`
+`);
+    const worktree = {};
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        worktree.path = line.slice(9);
+      } else if (line.startsWith("HEAD ")) {
+        worktree.commit = line.slice(5);
+      } else if (line.startsWith("branch ")) {
+        worktree.branch = line.slice(7).replace("refs/heads/", "");
+      } else if (line === "bare") {
+        worktree.isBare = true;
+      } else if (line === "detached") {
+        worktree.branch = "(detached)";
+      }
+    }
+    if (worktree.path) {
+      worktrees.push({
+        path: worktree.path,
+        branch: worktree.branch || "(unknown)",
+        commit: worktree.commit || "",
+        isMain: worktrees.length === 0,
+        isBare: worktree.isBare || false
+      });
+    }
+  }
+  return worktrees;
+}
+async function branchExists(repoRoot, branch) {
+  try {
+    await execGit(["rev-parse", "--verify", `refs/heads/${branch}`], repoRoot);
+    return true;
+  } catch {
+    try {
+      await execGit(["rev-parse", "--verify", `refs/remotes/origin/${branch}`], repoRoot);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function getWorktreeDir(repoRoot, branch) {
+  const repoName = repoRoot.replace(/\//g, "-").replace(/^-/, "");
+  const sanitizedBranch = branch.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
+  const shortUuid = randomUUID().slice(0, 8);
+  return path.join(WORKTREES_DIR, `${repoName}--${sanitizedBranch}-${shortUuid}`);
+}
+function isValidWorktreePath(worktreePath) {
+  return worktreePath.startsWith(WORKTREES_DIR + path.sep);
+}
+function getWorktreesDir() {
+  return WORKTREES_DIR;
+}
+async function detectWorktreeInfo(workingDir) {
+  if (!isValidWorktreePath(workingDir)) {
+    return null;
+  }
+  try {
+    const branchOutput = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
+    const branch = branchOutput?.trim();
+    if (!branch) {
+      log7.debug(`Could not detect branch for worktree at ${workingDir}`);
+      return null;
+    }
+    const gitDirOutput = await execGit(["rev-parse", "--git-common-dir"], workingDir);
+    let repoRoot = gitDirOutput?.trim();
+    if (repoRoot) {
+      if (repoRoot.endsWith("/.git")) {
+        repoRoot = repoRoot.slice(0, -5);
+      } else if (repoRoot.endsWith(".git")) {
+        repoRoot = repoRoot.slice(0, -4);
+      }
+    }
+    log7.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
+    return {
+      worktreePath: workingDir,
+      branch,
+      repoRoot: repoRoot || workingDir
+    };
+  } catch (err) {
+    log7.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
+    return null;
+  }
+}
+async function createWorktree(repoRoot, branch, targetDir) {
+  log7.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
+  const parentDir = path.dirname(targetDir);
+  log7.debug(`Creating parent directory: ${parentDir}`);
+  await fs.mkdir(parentDir, { recursive: true });
+  const exists = await branchExists(repoRoot, branch);
+  if (exists) {
+    log7.debug(`Branch '${branch}' exists, adding worktree`);
+    await execGit(["worktree", "add", targetDir, branch], repoRoot);
+  } else {
+    log7.debug(`Branch '${branch}' does not exist, creating with worktree`);
+    await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
+  }
+  log7.info(`Worktree created successfully: ${targetDir}`);
+  return targetDir;
+}
+async function removeWorktree(repoRoot, worktreePath) {
+  log7.info(`Removing worktree: ${worktreePath}`);
+  try {
+    await execGit(["worktree", "remove", worktreePath], repoRoot);
+    log7.debug("Worktree removed cleanly");
+  } catch (err) {
+    log7.debug(`Clean remove failed (${err}), trying force remove`);
+    await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
+  }
+  log7.debug("Pruning stale worktree references");
+  await execGit(["worktree", "prune"], repoRoot);
+  log7.info("Worktree removed and pruned successfully");
+}
+async function findWorktreeByBranch(repoRoot, branch) {
+  const worktrees = await listWorktrees(repoRoot);
+  return worktrees.find((wt) => wt.branch === branch) || null;
+}
+function isValidBranchName(name) {
+  if (!name || name.length === 0)
+    return false;
+  if (name.startsWith("/") || name.endsWith("/"))
+    return false;
+  if (name.includes(".."))
+    return false;
+  if (/[\s~^:?*[\]\\]/.test(name))
+    return false;
+  if (name.startsWith("-"))
+    return false;
+  if (name.endsWith(".lock"))
+    return false;
+  if (name.includes("@{"))
+    return false;
+  if (name === "@")
+    return false;
+  if (/\.\./.test(name))
+    return false;
+  return true;
+}
+async function readMetadataStore() {
+  try {
+    const content = await fs.readFile(METADATA_STORE_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeMetadataStore(store) {
+  try {
+    await fs.mkdir(path.dirname(METADATA_STORE_PATH), { recursive: true });
+    await fs.writeFile(METADATA_STORE_PATH, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 384 });
+    await fs.chmod(METADATA_STORE_PATH, 384);
+  } catch (err) {
+    log7.warn(`Failed to write worktree metadata store: ${err}`);
+  }
+}
+async function writeWorktreeMetadata(worktreePath, metadata) {
+  const store = await readMetadataStore();
+  store[worktreePath] = metadata;
+  await writeMetadataStore(store);
+  log7.debug(`Wrote worktree metadata for: ${worktreePath}`);
+}
+async function readWorktreeMetadata(worktreePath) {
+  const store = await readMetadataStore();
+  return store[worktreePath] || null;
+}
+async function updateWorktreeActivity(worktreePath, sessionId) {
+  const store = await readMetadataStore();
+  const existing = store[worktreePath];
+  if (!existing)
+    return;
+  existing.lastActivityAt = new Date().toISOString();
+  if (sessionId !== undefined) {
+    existing.sessionId = sessionId;
+  }
+  store[worktreePath] = existing;
+  await writeMetadataStore(store);
+}
+async function removeWorktreeMetadata(worktreePath) {
+  const store = await readMetadataStore();
+  if (store[worktreePath]) {
+    delete store[worktreePath];
+    await writeMetadataStore(store);
+    log7.debug(`Removed worktree metadata for: ${worktreePath}`);
+  }
+}
+var log7, WORKTREES_DIR, METADATA_STORE_PATH;
+var init_worktree = __esm(() => {
+  init_logger();
+  log7 = createLogger("git-wt");
+  WORKTREES_DIR = path.join(homedir4(), ".claude-threads", "worktrees");
+  METADATA_STORE_PATH = path.join(homedir4(), ".claude-threads", "worktree-metadata.json");
+});
+
 // node_modules/pend/index.js
 var require_pend = __commonJS((exports, module) => {
   module.exports = Pend;
@@ -50840,82 +51242,8 @@ async function setupSlackPlatform(id, existing) {
 }
 
 // src/platform/base-client.ts
+init_logger();
 import { EventEmitter } from "events";
-
-// src/utils/logger.ts
-var globalLogHandler = null;
-function setLogHandler(handler) {
-  globalLogHandler = handler;
-}
-var COMPONENT_WIDTH = 10;
-function createLogger(component, useStderr = false, sessionId) {
-  const isDebug = () => process.env.DEBUG === "1";
-  const consoleLog = useStderr ? console.error : console.log;
-  const paddedComponent = component.length > COMPONENT_WIDTH ? component.substring(0, COMPONENT_WIDTH) : component.padEnd(COMPONENT_WIDTH);
-  const formatMessage = (msg, args) => {
-    if (args.length === 0)
-      return msg;
-    return `${msg} ${args.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ")}`;
-  };
-  const DEFAULT_JSON_MAX_LEN = 60;
-  return {
-    debug: (msg, ...args) => {
-      if (isDebug()) {
-        const fullMsg = formatMessage(msg, args);
-        if (globalLogHandler) {
-          globalLogHandler("debug", paddedComponent, fullMsg, sessionId);
-        } else {
-          consoleLog(`[${paddedComponent}] ${fullMsg}`);
-        }
-      }
-    },
-    debugJson: (label, data, maxLen = DEFAULT_JSON_MAX_LEN) => {
-      if (isDebug()) {
-        const json2 = JSON.stringify(data);
-        const truncated = json2.length > maxLen ? `${json2.substring(0, maxLen)}…` : json2;
-        const fullMsg = `${label}: ${truncated}`;
-        if (globalLogHandler) {
-          globalLogHandler("debug", paddedComponent, fullMsg, sessionId);
-        } else {
-          consoleLog(`[${paddedComponent}] ${fullMsg}`);
-        }
-      }
-    },
-    info: (msg, ...args) => {
-      const fullMsg = formatMessage(msg, args);
-      if (globalLogHandler) {
-        globalLogHandler("info", paddedComponent, fullMsg, sessionId);
-      } else {
-        consoleLog(`[${paddedComponent}] ${fullMsg}`);
-      }
-    },
-    warn: (msg, ...args) => {
-      const fullMsg = formatMessage(msg, args);
-      if (globalLogHandler) {
-        globalLogHandler("warn", paddedComponent, fullMsg, sessionId);
-      } else {
-        console.warn(`[${paddedComponent}] ⚠️ ${fullMsg}`);
-      }
-    },
-    error: (msg, err) => {
-      const fullMsg = err && isDebug() ? `${msg}
-${err.stack || err.message}` : msg;
-      if (globalLogHandler) {
-        globalLogHandler("error", paddedComponent, fullMsg, sessionId);
-      } else {
-        console.error(`[${paddedComponent}] ❌ ${msg}`);
-        if (err && isDebug()) {
-          console.error(err);
-        }
-      }
-    },
-    forSession: (sid) => createLogger(component, useStderr, sid)
-  };
-}
-var mcpLogger = createLogger("MCP", true);
-var wsLogger = createLogger("ws", false);
-
-// src/platform/base-client.ts
 var log = createLogger("base-client");
 
 class BasePlatformClient extends EventEmitter {
@@ -51038,6 +51366,9 @@ class BasePlatformClient extends EventEmitter {
     this.lastMessageAt = Date.now();
   }
 }
+// src/platform/mattermost/client.ts
+init_logger();
+
 // src/version.ts
 import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
 import { dirname as dirname3, resolve as resolve2 } from "path";
@@ -51797,6 +52128,9 @@ class MattermostClient extends BasePlatformClient {
     }));
   }
 }
+// src/platform/slack/client.ts
+init_logger();
+
 // src/platform/slack/formatter.ts
 class SlackFormatter {
   formatBold(text) {
@@ -52510,6 +52844,7 @@ class SlackClient extends BasePlatformClient {
   }
 }
 // src/mattermost/api.ts
+init_logger();
 var log4 = createLogger("mm-api");
 async function mattermostApi(config, method, path, body) {
   const url = `${config.url}/api/v4${path}`;
@@ -52579,6 +52914,7 @@ async function createInteractivePost(config, channelId, message, reactions, root
 }
 
 // src/platform/mattermost/permission-api.ts
+init_logger();
 class MattermostPermissionApi {
   apiConfig;
   config;
@@ -52707,6 +53043,7 @@ class MattermostPermissionApi {
 }
 
 // src/platform/slack/permission-api.ts
+init_logger();
 var SLACK_API_BASE = "https://slack.com/api";
 async function slackApi(method, token, body) {
   const url = `${SLACK_API_BASE}/${method}`;
@@ -52919,6 +53256,7 @@ class SlackPermissionApi {
 import { EventEmitter as EventEmitter4 } from "events";
 
 // src/persistence/session-store.ts
+init_logger();
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameSync, chmodSync as chmodSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
@@ -53145,11 +53483,13 @@ class SessionStore {
 init_emoji();
 
 // src/cleanup/scheduler.ts
+init_logger();
 import { existsSync as existsSync7 } from "fs";
 import { readdir, rm } from "fs/promises";
 import { join as join5 } from "path";
 
 // src/persistence/thread-logger.ts
+init_logger();
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, appendFileSync, readdirSync, statSync, unlinkSync, rmdirSync, readFileSync as readFileSync5, chmodSync as chmodSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3, dirname as dirname4 } from "path";
@@ -53424,309 +53764,8 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
   }
 }
 
-// src/git/worktree.ts
-import { spawn as spawn2 } from "child_process";
-import { randomUUID } from "crypto";
-import * as path from "path";
-import * as fs from "fs/promises";
-import { homedir as homedir4 } from "os";
-var log7 = createLogger("git-wt");
-var WORKTREES_DIR = path.join(homedir4(), ".claude-threads", "worktrees");
-async function execGit(args, cwd) {
-  const cmd = `git ${args.join(" ")}`;
-  log7.debug(`Executing: ${cmd}`);
-  return new Promise((resolve3, reject) => {
-    const proc = spawn2("git", args, { cwd });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      if (code === 0) {
-        log7.debug(`${cmd} → success`);
-        resolve3(stdout.trim());
-      } else {
-        log7.debug(`${cmd} → failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
-        reject(new Error(`git ${args.join(" ")} failed: ${stderr || stdout}`));
-      }
-    });
-    proc.on("error", (err) => {
-      log7.warn(`${cmd} → error: ${err}`);
-      reject(err);
-    });
-  });
-}
-async function isGitRepository(dir) {
-  try {
-    await execGit(["rev-parse", "--git-dir"], dir);
-    return true;
-  } catch (err) {
-    log7.debug(`Not a git repository: ${dir} (${err})`);
-    return false;
-  }
-}
-async function getRepositoryRoot(dir) {
-  return execGit(["rev-parse", "--show-toplevel"], dir);
-}
-async function getCurrentBranch(dir) {
-  try {
-    const branch = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], dir);
-    return branch === "HEAD" ? null : branch;
-  } catch {
-    return null;
-  }
-}
-async function getDefaultBranch(repoRoot) {
-  try {
-    const remoteHead = await execGit(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoRoot);
-    return remoteHead.replace("origin/", "");
-  } catch {
-    try {
-      await execGit(["rev-parse", "--verify", "main"], repoRoot);
-      return "main";
-    } catch {
-      try {
-        await execGit(["rev-parse", "--verify", "master"], repoRoot);
-        return "master";
-      } catch {
-        return "main";
-      }
-    }
-  }
-}
-async function isBranchMerged(repoRoot, branchName) {
-  try {
-    const defaultBranch = await getDefaultBranch(repoRoot);
-    if (branchName === defaultBranch) {
-      return false;
-    }
-    await execGit(["fetch", "origin", defaultBranch], repoRoot).catch(() => {});
-    const branchCommit = await execGit(["rev-parse", branchName], repoRoot);
-    const defaultCommit = await execGit(["rev-parse", `origin/${defaultBranch}`], repoRoot);
-    if (branchCommit === defaultCommit) {
-      return false;
-    }
-    await execGit(["merge-base", "--is-ancestor", branchName, `origin/${defaultBranch}`], repoRoot);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function hasUncommittedChanges(dir) {
-  try {
-    const staged = await execGit(["diff", "--cached", "--quiet"], dir).catch(() => "changes");
-    if (staged === "changes")
-      return true;
-    const unstaged = await execGit(["diff", "--quiet"], dir).catch(() => "changes");
-    if (unstaged === "changes")
-      return true;
-    const untracked = await execGit(["ls-files", "--others", "--exclude-standard"], dir);
-    return untracked.length > 0;
-  } catch {
-    return false;
-  }
-}
-async function listWorktrees(repoRoot) {
-  const output = await execGit(["worktree", "list", "--porcelain"], repoRoot);
-  const worktrees = [];
-  if (!output)
-    return worktrees;
-  const blocks = output.split(`
-
-`).filter(Boolean);
-  for (const block of blocks) {
-    const lines = block.split(`
-`);
-    const worktree = {};
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        worktree.path = line.slice(9);
-      } else if (line.startsWith("HEAD ")) {
-        worktree.commit = line.slice(5);
-      } else if (line.startsWith("branch ")) {
-        worktree.branch = line.slice(7).replace("refs/heads/", "");
-      } else if (line === "bare") {
-        worktree.isBare = true;
-      } else if (line === "detached") {
-        worktree.branch = "(detached)";
-      }
-    }
-    if (worktree.path) {
-      worktrees.push({
-        path: worktree.path,
-        branch: worktree.branch || "(unknown)",
-        commit: worktree.commit || "",
-        isMain: worktrees.length === 0,
-        isBare: worktree.isBare || false
-      });
-    }
-  }
-  return worktrees;
-}
-async function branchExists(repoRoot, branch) {
-  try {
-    await execGit(["rev-parse", "--verify", `refs/heads/${branch}`], repoRoot);
-    return true;
-  } catch {
-    try {
-      await execGit(["rev-parse", "--verify", `refs/remotes/origin/${branch}`], repoRoot);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-function getWorktreeDir(repoRoot, branch) {
-  const repoName = repoRoot.replace(/\//g, "-").replace(/^-/, "");
-  const sanitizedBranch = branch.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
-  const shortUuid = randomUUID().slice(0, 8);
-  return path.join(WORKTREES_DIR, `${repoName}--${sanitizedBranch}-${shortUuid}`);
-}
-function isValidWorktreePath(worktreePath) {
-  return worktreePath.startsWith(WORKTREES_DIR + path.sep);
-}
-function getWorktreesDir() {
-  return WORKTREES_DIR;
-}
-async function detectWorktreeInfo(workingDir) {
-  if (!isValidWorktreePath(workingDir)) {
-    return null;
-  }
-  try {
-    const branchOutput = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
-    const branch = branchOutput?.trim();
-    if (!branch) {
-      log7.debug(`Could not detect branch for worktree at ${workingDir}`);
-      return null;
-    }
-    const gitDirOutput = await execGit(["rev-parse", "--git-common-dir"], workingDir);
-    let repoRoot = gitDirOutput?.trim();
-    if (repoRoot) {
-      if (repoRoot.endsWith("/.git")) {
-        repoRoot = repoRoot.slice(0, -5);
-      } else if (repoRoot.endsWith(".git")) {
-        repoRoot = repoRoot.slice(0, -4);
-      }
-    }
-    log7.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
-    return {
-      worktreePath: workingDir,
-      branch,
-      repoRoot: repoRoot || workingDir
-    };
-  } catch (err) {
-    log7.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
-    return null;
-  }
-}
-async function createWorktree(repoRoot, branch, targetDir) {
-  log7.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
-  const parentDir = path.dirname(targetDir);
-  log7.debug(`Creating parent directory: ${parentDir}`);
-  await fs.mkdir(parentDir, { recursive: true });
-  const exists = await branchExists(repoRoot, branch);
-  if (exists) {
-    log7.debug(`Branch '${branch}' exists, adding worktree`);
-    await execGit(["worktree", "add", targetDir, branch], repoRoot);
-  } else {
-    log7.debug(`Branch '${branch}' does not exist, creating with worktree`);
-    await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
-  }
-  log7.info(`Worktree created successfully: ${targetDir}`);
-  return targetDir;
-}
-async function removeWorktree(repoRoot, worktreePath) {
-  log7.info(`Removing worktree: ${worktreePath}`);
-  try {
-    await execGit(["worktree", "remove", worktreePath], repoRoot);
-    log7.debug("Worktree removed cleanly");
-  } catch (err) {
-    log7.debug(`Clean remove failed (${err}), trying force remove`);
-    await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
-  }
-  log7.debug("Pruning stale worktree references");
-  await execGit(["worktree", "prune"], repoRoot);
-  log7.info("Worktree removed and pruned successfully");
-}
-async function findWorktreeByBranch(repoRoot, branch) {
-  const worktrees = await listWorktrees(repoRoot);
-  return worktrees.find((wt) => wt.branch === branch) || null;
-}
-function isValidBranchName(name) {
-  if (!name || name.length === 0)
-    return false;
-  if (name.startsWith("/") || name.endsWith("/"))
-    return false;
-  if (name.includes(".."))
-    return false;
-  if (/[\s~^:?*[\]\\]/.test(name))
-    return false;
-  if (name.startsWith("-"))
-    return false;
-  if (name.endsWith(".lock"))
-    return false;
-  if (name.includes("@{"))
-    return false;
-  if (name === "@")
-    return false;
-  if (/\.\./.test(name))
-    return false;
-  return true;
-}
-var METADATA_STORE_PATH = path.join(homedir4(), ".claude-threads", "worktree-metadata.json");
-async function readMetadataStore() {
-  try {
-    const content = await fs.readFile(METADATA_STORE_PATH, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function writeMetadataStore(store) {
-  try {
-    await fs.mkdir(path.dirname(METADATA_STORE_PATH), { recursive: true });
-    await fs.writeFile(METADATA_STORE_PATH, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 384 });
-    await fs.chmod(METADATA_STORE_PATH, 384);
-  } catch (err) {
-    log7.warn(`Failed to write worktree metadata store: ${err}`);
-  }
-}
-async function writeWorktreeMetadata(worktreePath, metadata) {
-  const store = await readMetadataStore();
-  store[worktreePath] = metadata;
-  await writeMetadataStore(store);
-  log7.debug(`Wrote worktree metadata for: ${worktreePath}`);
-}
-async function readWorktreeMetadata(worktreePath) {
-  const store = await readMetadataStore();
-  return store[worktreePath] || null;
-}
-async function updateWorktreeActivity(worktreePath, sessionId) {
-  const store = await readMetadataStore();
-  const existing = store[worktreePath];
-  if (!existing)
-    return;
-  existing.lastActivityAt = new Date().toISOString();
-  if (sessionId !== undefined) {
-    existing.sessionId = sessionId;
-  }
-  store[worktreePath] = existing;
-  await writeMetadataStore(store);
-}
-async function removeWorktreeMetadata(worktreePath) {
-  const store = await readMetadataStore();
-  if (store[worktreePath]) {
-    delete store[worktreePath];
-    await writeMetadataStore(store);
-    log7.debug(`Removed worktree metadata for: ${worktreePath}`);
-  }
-}
-
 // src/cleanup/scheduler.ts
+init_worktree();
 var log8 = createLogger("cleanup");
 var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
 var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
@@ -53900,6 +53939,9 @@ class CleanupScheduler {
     return result;
   }
 }
+// src/operations/monitor/handler.ts
+init_logger();
+
 // src/session/timer-manager.ts
 function createSessionTimers() {
   return {
@@ -53961,6 +54003,7 @@ function getSessionStatus(session) {
 }
 
 // src/claude/cli.ts
+init_logger();
 import { spawn as spawn3 } from "child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve3, dirname as dirname6 } from "path";
@@ -54845,15 +54888,35 @@ var handleWorktree = async (ctx, args) => {
     }
     switch (subcommandOrBranch) {
       case "list":
-        await ctx.sessionManager.listWorktreesCommand(ctx.threadId, ctx.username);
+        if (ctx.commandContext === "first-message") {
+          await ctx.sessionManager.listWorktreesWithoutSession(ctx.client.platformId, ctx.threadId);
+        } else {
+          await ctx.sessionManager.listWorktreesCommand(ctx.threadId, ctx.username);
+        }
         return { handled: true };
-      case "switch":
+      case "switch": {
         if (!subArgs) {
           await ctx.client.createPost(`❌ Usage: ${ctx.formatter.formatCode("!worktree switch <branch>")}`, ctx.threadId);
           return { handled: true };
         }
-        await ctx.sessionManager.switchToWorktree(ctx.threadId, subArgs, ctx.username);
+        const switchParts = subArgs.split(/\s+/);
+        const branchName = switchParts[0];
+        const remainingPrompt = switchParts.slice(1).join(" ").trim();
+        if (ctx.commandContext === "first-message") {
+          if (remainingPrompt) {
+            return {
+              worktreeBranch: branchName,
+              continueProcessing: false,
+              remainingText: remainingPrompt,
+              sessionOptions: { switchToExisting: true }
+            };
+          }
+          await ctx.sessionManager.switchToWorktreeWithoutSession(ctx.client.platformId, ctx.threadId, branchName);
+          return { handled: true };
+        }
+        await ctx.sessionManager.switchToWorktree(ctx.threadId, branchName, ctx.username);
         return { handled: true };
+      }
       case "remove":
         if (!subArgs) {
           await ctx.client.createPost(`❌ Usage: ${ctx.formatter.formatCode("!worktree remove <branch>")}`, ctx.threadId);
@@ -55065,6 +55128,7 @@ import { randomUUID as randomUUID4 } from "crypto";
 import { existsSync as existsSync11 } from "fs";
 
 // src/utils/keep-alive.ts
+init_logger();
 import { spawn as spawn4 } from "child_process";
 var log10 = createLogger("keepalive");
 
@@ -55253,6 +55317,7 @@ class KeepAliveManager {
 var keepAlive = new KeepAliveManager;
 
 // src/utils/error-handler/index.ts
+init_logger();
 var log11 = createLogger("error");
 
 class SessionError extends Error {
@@ -55321,6 +55386,9 @@ function logSilentError(context, error) {
   log11.debug(`[${context}] Silently caught: ${message}`);
 }
 
+// src/session/lifecycle.ts
+init_logger();
+
 // src/utils/session-log.ts
 function createSessionLog(baseLog) {
   return (session) => {
@@ -55332,7 +55400,9 @@ function createSessionLog(baseLog) {
 }
 
 // src/operations/post-helpers/index.ts
+init_logger();
 init_emoji();
+init_worktree();
 var log12 = createLogger("helpers");
 var sessionLog = createSessionLog(log12);
 var POST_TYPES = {
@@ -55416,6 +55486,7 @@ function updateLastMessage(session, post2) {
 }
 
 // src/claude/quick-query.ts
+init_logger();
 import { spawn as spawn5 } from "child_process";
 var log13 = createLogger("query");
 async function quickQuery(options2) {
@@ -55500,6 +55571,7 @@ async function quickQuery(options2) {
 }
 
 // src/operations/suggestions/title.ts
+init_logger();
 var log14 = createLogger("title");
 var SUGGESTION_TIMEOUT = 15000;
 var MIN_TITLE_LENGTH = 3;
@@ -55612,6 +55684,7 @@ async function suggestSessionMetadata(context) {
 }
 
 // src/operations/suggestions/tag.ts
+init_logger();
 var log15 = createLogger("tags");
 var SUGGESTION_TIMEOUT2 = 15000;
 var MAX_TAGS = 3;
@@ -59200,7 +59273,11 @@ class BugReportExecutor extends BaseExecutor {
 }
 // src/operations/executors/worktree-prompt.ts
 init_emoji();
+init_logger();
 var log16 = createLogger("wt-prompt");
+// src/operations/message-manager.ts
+init_logger();
+
 // src/operations/message-manager-events.ts
 import { EventEmitter as EventEmitter3 } from "events";
 
@@ -59229,6 +59306,7 @@ function createMessageManagerEvents() {
 }
 
 // src/operations/streaming/handler.ts
+init_logger();
 var import_yauzl = __toESM(require_yauzl(), 1);
 import { createGunzip } from "zlib";
 import { pipeline } from "stream/promises";
@@ -60515,6 +60593,9 @@ function formatUptime(startedAt) {
   return `${minutes}m`;
 }
 
+// src/operations/sticky-message/handler.ts
+init_logger();
+
 // src/utils/pr-detector.ts
 var PR_PATTERNS = [
   {
@@ -65162,6 +65243,8 @@ function getUpdateInfo() {
 
 // src/operations/commands/handler.ts
 init_emoji();
+init_logger();
+init_worktree();
 var log20 = createLogger("commands");
 var sessionLog2 = createSessionLog(log20);
 async function restartClaudeSession(session, cliOptions, ctx, actionName) {
@@ -65676,6 +65759,8 @@ async function handleBugReportApproval(session, isApproved, username) {
   session.messageManager?.clearPendingBugReport();
 }
 // src/operations/suggestions/branch.ts
+init_worktree();
+init_logger();
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync2 = promisify3(exec3);
@@ -65755,7 +65840,9 @@ async function suggestBranchNames(workingDir, userMessage) {
 }
 
 // src/operations/worktree/handler.ts
+init_worktree();
 import { randomUUID as randomUUID3 } from "crypto";
+init_logger();
 var log22 = createLogger("worktree");
 var sessionLog3 = createSessionLog(log22);
 function parseWorktreeError(error) {
@@ -66183,33 +66270,40 @@ async function switchToWorktree(session, branchOrPath, username, changeDirectory
   session.messageManager?.setWorktreeInfo(target.path, target.branch);
   session.isWorktreeOwner = false;
 }
-async function buildWorktreeListMessage(session) {
-  const isRepo = await isGitRepository(session.workingDir);
+async function buildWorktreeListMessageFromDir(workingDir, formatter, currentWorkingDir) {
+  const isRepo = await isGitRepository(workingDir);
   if (!isRepo) {
-    sessionLog3(session).warn(`\uD83C\uDF3F Not a git repository: ${session.workingDir}`);
     return null;
   }
-  const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+  const repoRoot = await getRepositoryRoot(workingDir);
   const worktrees = await listWorktrees(repoRoot);
   if (worktrees.length === 0) {
-    sessionLog3(session).debug(`\uD83C\uDF3F No worktrees found`);
     return "No worktrees found for this repository";
   }
   const shortRepoRoot = repoRoot.replace(process.env.HOME || "", "~");
-  const fmt = session.platform.getFormatter();
-  let message = `\uD83D\uDCCB ${fmt.formatBold("Worktrees for")} ${fmt.formatCode(shortRepoRoot)}:
+  let message = `\uD83D\uDCCB ${formatter.formatBold("Worktrees for")} ${formatter.formatCode(shortRepoRoot)}:
 
 `;
   for (const wt of worktrees) {
     const shortPath = wt.isMain ? wt.path.replace(process.env.HOME || "", "~") : shortenPath(wt.path, undefined, { path: wt.path, branch: wt.branch });
-    const isCurrent = session.workingDir === wt.path;
+    const isCurrent = currentWorkingDir === wt.path;
     const marker = isCurrent ? " ← current" : "";
     const label = wt.isMain ? "(main repository)" : "";
-    message += `• ${fmt.formatCode(wt.branch)} → ${fmt.formatCode(shortPath)} ${label}${marker}
+    message += `• ${formatter.formatCode(wt.branch)} → ${formatter.formatCode(shortPath)} ${label}${marker}
 `;
   }
   return message;
 }
+async function buildWorktreeListMessage(session) {
+  const repoRoot = session.worktreeInfo?.repoRoot;
+  const isRepo = await isGitRepository(session.workingDir);
+  if (!isRepo) {
+    sessionLog3(session).warn(`\uD83C\uDF3F Not a git repository: ${session.workingDir}`);
+    return null;
+  }
+  const workingDirForList = repoRoot || session.workingDir;
+  return buildWorktreeListMessageFromDir(workingDirForList, session.platform.getFormatter(), session.workingDir);
+}
 async function listWorktreesCommand(session) {
   const message = await buildWorktreeListMessage(session);
   if (message === null) {
@@ -66299,6 +66393,7 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
   }
 }
 // src/operations/events/handler.ts
+init_logger();
 var log23 = createLogger("events");
 var sessionLog4 = createSessionLog(log23);
 function detectAndExecuteClaudeCommands(text, session, ctx) {
@@ -66547,6 +66642,7 @@ function createSessionContext(config, state, ops) {
 }
 // src/operations/context-prompt/handler.ts
 init_emoji();
+init_logger();
 var log24 = createLogger("context");
 var sessionLog5 = createSessionLog(log24);
 var CONTEXT_PROMPT_TIMEOUT_MS = 30000;
@@ -66794,6 +66890,7 @@ function formatRelativeTime(date) {
   return `${diffMin} min ago`;
 }
 // src/session/lifecycle.ts
+init_worktree();
 var log25 = createLogger("lifecycle");
 var sessionLog6 = createSessionLog(log25);
 function mutableSessions(ctx) {
@@ -67719,6 +67816,7 @@ class SessionMonitor {
 }
 // src/operations/plugin/handler.ts
 import { spawn as spawn7 } from "child_process";
+init_logger();
 var log27 = createLogger("plugin");
 var sessionLog7 = createSessionLog(log27);
 async function runPluginCommand(args, cwd, timeout2 = 60000) {
@@ -67939,6 +68037,7 @@ class SessionRegistry {
 }
 
 // src/session/manager.ts
+init_logger();
 var log28 = createLogger("manager");
 
 class SessionManager extends EventEmitter4 {
@@ -68710,6 +68809,40 @@ class SessionManager extends EventEmitter4 {
       return;
     await listWorktreesCommand(session);
   }
+  async listWorktreesWithoutSession(platformId, threadId) {
+    const platform = this.platforms.get(platformId);
+    if (!platform)
+      return;
+    const formatter = platform.getFormatter();
+    const message = await buildWorktreeListMessageFromDir(this.workingDir, formatter, this.workingDir);
+    if (message === null) {
+      await platform.createPost(`❌ Current directory is not a git repository`, threadId);
+      return;
+    }
+    await platform.createPost(message, threadId);
+  }
+  async switchToWorktreeWithoutSession(platformId, threadId, branchOrPath) {
+    const platform = this.platforms.get(platformId);
+    if (!platform)
+      return;
+    const formatter = platform.getFormatter();
+    const { listWorktrees: listWorktrees2, getRepositoryRoot: getRepositoryRoot2, isGitRepository: isGitRepository2 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
+    const isRepo = await isGitRepository2(this.workingDir);
+    if (!isRepo) {
+      await platform.createPost(`❌ Current directory is not a git repository`, threadId);
+      return;
+    }
+    const repoRoot = await getRepositoryRoot2(this.workingDir);
+    const worktrees = await listWorktrees2(repoRoot);
+    const target = worktrees.find((wt) => wt.branch === branchOrPath || wt.path === branchOrPath || wt.path.endsWith(`/${branchOrPath}`));
+    if (!target) {
+      await platform.createPost(`❌ No worktree found for ${formatter.formatCode(branchOrPath)}`, threadId);
+      return;
+    }
+    await platform.createPost(`✅ Switched to worktree ${formatter.formatCode(target.branch)} at ${formatter.formatCode(target.path)}
+
+Mention me to start a session in this worktree.`, threadId);
+  }
   async removeWorktreeCommand(threadId, branchOrPath, username) {
     const session = this.findSessionByThreadId(threadId);
     if (!session)
@@ -68782,7 +68915,7 @@ class SessionManager extends EventEmitter4 {
   applySideConversationLimits(session) {
     const MAX_COUNT = 5;
     const MAX_TOTAL_CHARS = 2000;
-    const MAX_AGE_MS = 30 * 60 * 1000;
+    const MAX_AGE_MS = 1800000;
     const now = Date.now();
     let convs = session.pendingSideConversations || [];
     convs = convs.filter((c) => now - c.timestamp.getTime() < MAX_AGE_MS);
@@ -68804,7 +68937,11 @@ class SessionManager extends EventEmitter4 {
     const threadId = replyToPostId || "";
     const session = this.registry.find(platformId, threadId);
     if (session) {
-      await this.createAndSwitchToWorktree(session.threadId, branch, username);
+      if (initialOptions?.switchToExisting) {
+        await this.switchToWorktree(session.threadId, branch, username);
+      } else {
+        await this.createAndSwitchToWorktree(session.threadId, branch, username);
+      }
     }
   }
   setShuttingDown() {
@@ -79307,6 +79444,9 @@ async function startUI(options2) {
   return createUIProvider(options2);
 }
 
+// src/index.ts
+init_logger();
+
 // src/message-handler.ts
 async function handleMessage(client, session, post2, user, options2) {
   const { platformId, logger, onKill } = options2;
@@ -79485,7 +79625,7 @@ async function handleMessage(client, session, post2, user, options2) {
         prompt = prompt.replace(/on branch\s+\S+/i, "").trim();
       }
     }
-    if (!prompt.trim() && !files?.length) {
+    if (!prompt.trim() && !files?.length && !worktreeBranch) {
       await client.createPost(`Mention me with your request`, threadRoot);
       return;
     }
@@ -79506,9 +79646,11 @@ async function handleMessage(client, session, post2, user, options2) {
 }
 
 // src/auto-update/manager.ts
+init_logger();
 import { EventEmitter as EventEmitter9 } from "events";
 
 // src/auto-update/checker.ts
+init_logger();
 import { EventEmitter as EventEmitter7 } from "events";
 var log29 = createLogger("checker");
 var PACKAGE_NAME = "claude-threads";
@@ -79639,6 +79781,7 @@ class UpdateChecker extends EventEmitter7 {
 }
 
 // src/auto-update/scheduler.ts
+init_logger();
 import { EventEmitter as EventEmitter8 } from "events";
 
 // src/auto-update/types.ts
@@ -79906,6 +80049,7 @@ class UpdateScheduler extends EventEmitter8 {
 }
 
 // src/auto-update/installer.ts
+init_logger();
 import { spawn as spawn8, spawnSync } from "child_process";
 import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname8, resolve as resolve6 } from "path";

package/dist/mcp/permission-server.js

@@ -38568,15 +38568,35 @@ var handleWorktree = async (ctx, args) => {
     }
     switch (subcommandOrBranch) {
       case "list":
-        await ctx.sessionManager.listWorktreesCommand(ctx.threadId, ctx.username);
+        if (ctx.commandContext === "first-message") {
+          await ctx.sessionManager.listWorktreesWithoutSession(ctx.client.platformId, ctx.threadId);
+        } else {
+          await ctx.sessionManager.listWorktreesCommand(ctx.threadId, ctx.username);
+        }
         return { handled: true };
-      case "switch":
+      case "switch": {
         if (!subArgs) {
           await ctx.client.createPost(`❌ Usage: ${ctx.formatter.formatCode("!worktree switch <branch>")}`, ctx.threadId);
           return { handled: true };
         }
-        await ctx.sessionManager.switchToWorktree(ctx.threadId, subArgs, ctx.username);
+        const switchParts = subArgs.split(/\s+/);
+        const branchName = switchParts[0];
+        const remainingPrompt = switchParts.slice(1).join(" ").trim();
+        if (ctx.commandContext === "first-message") {
+          if (remainingPrompt) {
+            return {
+              worktreeBranch: branchName,
+              continueProcessing: false,
+              remainingText: remainingPrompt,
+              sessionOptions: { switchToExisting: true }
+            };
+          }
+          await ctx.sessionManager.switchToWorktreeWithoutSession(ctx.client.platformId, ctx.threadId, branchName);
+          return { handled: true };
+        }
+        await ctx.sessionManager.switchToWorktree(ctx.threadId, branchName, ctx.username);
         return { handled: true };
+      }
       case "remove":
         if (!subArgs) {
           await ctx.client.createPost(`❌ Usage: ${ctx.formatter.formatCode("!worktree remove <branch>")}`, ctx.threadId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",