mattermost-claude-code 0.10.10 → 0.11.0

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.11.0] - 2025-12-28
+
+### Added
+- **Git worktree support** - Isolate file changes between concurrent sessions
+  - Smart detection prompts for a branch when uncommitted changes or concurrent sessions exist
+  - Reply with a branch name to create a worktree, or react with ❌ to skip
+  - Inline syntax: `@bot on branch feature/x help me implement...`
+  - `!worktree <branch>` - Create and switch to a git worktree
+  - `!worktree list` - List all worktrees for the repo
+  - `!worktree switch <branch>` - Switch to an existing worktree
+  - `!worktree remove <branch>` - Remove a worktree
+  - `!worktree off` - Disable worktree prompts for this session
+  - Configure via `WORKTREE_MODE=off|prompt|require` (default: `prompt`)
+  - Worktrees persist after session ends (manual cleanup)
+  - Session header shows worktree info when active
+
+## [0.10.11] - 2025-12-28
+
+### Fixed
+- **Permission prompts now update after approval/denial** - Shows result inline
+  - "⚠️ Permission requested" → "✅ Allowed by @user" or "❌ Denied by @user"
+  - Consistent with plan approval and message approval behavior
+
 ## [0.10.10] - 2025-12-28
 
 ### Fixed

package/dist/claude/session.d.ts

@@ -1,7 +1,8 @@
 import { ClaudeCli } from './cli.js';
 import { MattermostClient } from '../mattermost/client.js';
 import { MattermostFile } from '../mattermost/types.js';
-import { PersistedSession } from '../persistence/session-store.js';
+import { PersistedSession, WorktreeInfo } from '../persistence/session-store.js';
+import { WorktreeMode } from '../config.js';
 interface QuestionOption {
     label: string;
     description: string;
@@ -62,19 +63,25 @@ interface Session {
     wasInterrupted: boolean;
     inProgressTaskStart: number | null;
     activeToolStarts: Map<string, number>;
+    worktreeInfo?: WorktreeInfo;
+    pendingWorktreePrompt?: boolean;
+    worktreePromptDisabled?: boolean;
+    queuedPrompt?: string;
+    worktreePromptPostId?: string;
 }
 export declare class SessionManager {
     private mattermost;
     private workingDir;
     private skipPermissions;
     private chromeEnabled;
+    private worktreeMode;
     private debug;
     private sessions;
     private postIndex;
     private sessionStore;
     private cleanupTimer;
     private isShuttingDown;
-    constructor(mattermost: MattermostClient, workingDir: string, skipPermissions?: boolean, chromeEnabled?: boolean);
+    constructor(mattermost: MattermostClient, workingDir: string, skipPermissions?: boolean, chromeEnabled?: boolean, worktreeMode?: WorktreeMode);
     /**
      * Initialize session manager by resuming any persisted sessions.
      * Should be called before starting to listen for new messages.
@@ -115,6 +122,27 @@ export declare class SessionManager {
         prompt: string;
         files?: MattermostFile[];
     }, username: string, replyToPostId?: string): Promise<void>;
+    /**
+     * Start a session with an initial worktree specified.
+     * Used when user specifies "on branch X" or "!worktree X" in their initial message.
+     */
+    startSessionWithWorktree(options: {
+        prompt: string;
+        files?: MattermostFile[];
+    }, branch: string, username: string, replyToPostId?: string): Promise<void>;
+    /**
+     * Check if we should prompt for a worktree before starting work.
+     * Returns the reason string if we should prompt, or null if not.
+     */
+    private shouldPromptForWorktree;
+    /**
+     * Check if another session is using the same repository
+     */
+    private hasOtherSessionInRepo;
+    /**
+     * Post the worktree prompt message
+     */
+    private postWorktreePrompt;
     private handleEvent;
     private handleTaskComplete;
     private handleExitPlanMode;
@@ -181,6 +209,43 @@ export declare class SessionManager {
     private updateSessionHeader;
     /** Request approval for a message from an unauthorized user */
     requestMessageApproval(threadId: string, username: string, message: string): Promise<void>;
+    /**
+     * Handle a worktree branch response from user.
+     * Called when user replies with a branch name to the worktree prompt.
+     */
+    handleWorktreeBranchResponse(threadId: string, branchName: string, username: string): Promise<boolean>;
+    /**
+     * Handle ❌ reaction on worktree prompt - skip worktree and continue in main repo.
+     */
+    handleWorktreeSkip(threadId: string, username: string): Promise<void>;
+    /**
+     * Create a new worktree and switch the session to it.
+     */
+    createAndSwitchToWorktree(threadId: string, branch: string, username: string): Promise<void>;
+    /**
+     * Switch to an existing worktree.
+     */
+    switchToWorktree(threadId: string, branchOrPath: string, username: string): Promise<void>;
+    /**
+     * List all worktrees for the current repository.
+     */
+    listWorktreesCommand(threadId: string, _username: string): Promise<void>;
+    /**
+     * Remove a worktree.
+     */
+    removeWorktreeCommand(threadId: string, branchOrPath: string, username: string): Promise<void>;
+    /**
+     * Disable worktree prompts for a session.
+     */
+    disableWorktreePrompt(threadId: string, username: string): Promise<void>;
+    /**
+     * Check if a session has a pending worktree prompt.
+     */
+    hasPendingWorktreePrompt(threadId: string): boolean;
+    /**
+     * Get the worktree prompt post ID for a session.
+     */
+    getWorktreePromptPostId(threadId: string): string | undefined;
     /** Kill all active sessions (for graceful shutdown) */
     killAllSessions(): void;
     /** Kill all sessions AND unpersist them (for emergency shutdown - no resume) */

package/dist/claude/session.js

@@ -5,6 +5,7 @@ import { getUpdateInfo } from '../update-notifier.js';
 import { getReleaseNotes, getWhatsNewSummary } from '../changelog.js';
 import { SessionStore } from '../persistence/session-store.js';
 import { getMattermostLogo } from '../logo.js';
+import { isGitRepository, getRepositoryRoot, hasUncommittedChanges, listWorktrees, createWorktree, removeWorktree as removeGitWorktree, getWorktreeDir, findWorktreeByBranch, isValidBranchName, } from '../git/worktree.js';
 import { randomUUID } from 'crypto';
 import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
@@ -26,6 +27,7 @@ export class SessionManager {
     workingDir;
     skipPermissions;
     chromeEnabled;
+    worktreeMode;
     debug = process.env.DEBUG === '1' || process.argv.includes('--debug');
     // Multi-session storage
     sessions = new Map(); // threadId -> Session
@@ -36,11 +38,12 @@ export class SessionManager {
     cleanupTimer = null;
     // Shutdown flag to suppress exit messages during graceful shutdown
     isShuttingDown = false;
-    constructor(mattermost, workingDir, skipPermissions = false, chromeEnabled = false) {
+    constructor(mattermost, workingDir, skipPermissions = false, chromeEnabled = false, worktreeMode = 'prompt') {
         this.mattermost = mattermost;
         this.workingDir = workingDir;
         this.skipPermissions = skipPermissions;
         this.chromeEnabled = chromeEnabled;
+        this.worktreeMode = worktreeMode;
         // Listen for reactions to answer questions
         this.mattermost.on('reaction', async (reaction, user) => {
             try {
@@ -146,6 +149,11 @@ export class SessionManager {
             wasInterrupted: false,
             inProgressTaskStart: null,
             activeToolStarts: new Map(),
+            // Worktree state from persistence
+            worktreeInfo: state.worktreeInfo,
+            pendingWorktreePrompt: state.pendingWorktreePrompt,
+            worktreePromptDisabled: state.worktreePromptDisabled,
+            queuedPrompt: state.queuedPrompt,
         };
         // Register session
         this.sessions.set(state.threadId, session);
@@ -197,6 +205,11 @@ export class SessionManager {
             tasksPostId: session.tasksPostId,
             lastActivityAt: session.lastActivityAt.toISOString(),
             planApproved: session.planApproved,
+            // Worktree state
+            worktreeInfo: session.worktreeInfo,
+            pendingWorktreePrompt: session.pendingWorktreePrompt,
+            worktreePromptDisabled: session.worktreePromptDisabled,
+            queuedPrompt: session.queuedPrompt,
         };
         this.sessionStore.save(session.threadId, state);
         console.log(`  [persist] Saved session ${shortId}... (claudeId: ${session.claudeSessionId.substring(0, 8)}...)`);
@@ -348,12 +361,132 @@ export class SessionManager {
             this.sessions.delete(actualThreadId);
             return;
         }
+        // Check if we should prompt for worktree
+        const shouldPrompt = await this.shouldPromptForWorktree(session);
+        if (shouldPrompt) {
+            // Queue the original message and prompt for branch name
+            session.queuedPrompt = options.prompt;
+            session.pendingWorktreePrompt = true;
+            await this.postWorktreePrompt(session, shouldPrompt);
+            // Persist session with pending state
+            this.persistSession(session);
+            return; // Don't send message to Claude yet
+        }
         // Send the message to Claude (with images if present)
         const content = await this.buildMessageContent(options.prompt, options.files);
         claude.sendMessage(content);
         // Persist session for resume after restart
         this.persistSession(session);
     }
+    /**
+     * Start a session with an initial worktree specified.
+     * Used when user specifies "on branch X" or "!worktree X" in their initial message.
+     */
+    async startSessionWithWorktree(options, branch, username, replyToPostId) {
+        // Start the session normally first
+        await this.startSession(options, username, replyToPostId);
+        // Get the thread ID
+        const threadId = replyToPostId || '';
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // If session has a pending worktree prompt (from startSession), skip it
+        if (session.pendingWorktreePrompt) {
+            session.pendingWorktreePrompt = false;
+            if (session.worktreePromptPostId) {
+                try {
+                    await this.mattermost.updatePost(session.worktreePromptPostId, `✅ Using branch \`${branch}\` (specified in message)`);
+                }
+                catch (err) {
+                    console.error('  ⚠️ Failed to update worktree prompt:', err);
+                }
+                session.worktreePromptPostId = undefined;
+            }
+        }
+        // Create the worktree
+        await this.createAndSwitchToWorktree(threadId, branch, username);
+    }
+    /**
+     * Check if we should prompt for a worktree before starting work.
+     * Returns the reason string if we should prompt, or null if not.
+     */
+    async shouldPromptForWorktree(session) {
+        // Skip if worktree mode is off
+        if (this.worktreeMode === 'off')
+            return null;
+        // Skip if user disabled prompts for this session
+        if (session.worktreePromptDisabled)
+            return null;
+        // Skip if already in a worktree
+        if (session.worktreeInfo)
+            return null;
+        // Check if we're in a git repository
+        const isRepo = await isGitRepository(session.workingDir);
+        if (!isRepo)
+            return null;
+        // For 'require' mode, always prompt
+        if (this.worktreeMode === 'require') {
+            return 'require';
+        }
+        // For 'prompt' mode, check conditions
+        // Condition 1: uncommitted changes
+        const hasChanges = await hasUncommittedChanges(session.workingDir);
+        if (hasChanges)
+            return 'uncommitted';
+        // Condition 2: another session using the same repo
+        const repoRoot = await getRepositoryRoot(session.workingDir);
+        const hasConcurrent = this.hasOtherSessionInRepo(repoRoot, session.threadId);
+        if (hasConcurrent)
+            return 'concurrent';
+        return null;
+    }
+    /**
+     * Check if another session is using the same repository
+     */
+    hasOtherSessionInRepo(repoRoot, excludeThreadId) {
+        for (const [threadId, session] of this.sessions) {
+            if (threadId === excludeThreadId)
+                continue;
+            // Check if session's working directory is in the same repo
+            // (either the repo root or a worktree of the same repo)
+            if (session.workingDir === repoRoot)
+                return true;
+            if (session.worktreeInfo?.repoRoot === repoRoot)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Post the worktree prompt message
+     */
+    async postWorktreePrompt(session, reason) {
+        let message;
+        switch (reason) {
+            case 'uncommitted':
+                message = `🌿 **This repo has uncommitted changes.**\n` +
+                    `Reply with a branch name to work in an isolated worktree, or react with ❌ to continue in the main repo.`;
+                break;
+            case 'concurrent':
+                message = `⚠️ **Another session is already using this repo.**\n` +
+                    `Reply with a branch name to work in an isolated worktree, or react with ❌ to continue anyway.`;
+                break;
+            case 'require':
+                message = `🌿 **This deployment requires working in a worktree.**\n` +
+                    `Please reply with a branch name to continue.`;
+                break;
+            default:
+                message = `🌿 **Would you like to work in an isolated worktree?**\n` +
+                    `Reply with a branch name, or react with ❌ to continue in the main repo.`;
+        }
+        // Create post with ❌ reaction option (except for 'require' mode)
+        const reactionOptions = reason === 'require' ? [] : ['❌'];
+        const post = await this.mattermost.createInteractivePost(message, reactionOptions, session.threadId);
+        // Track the post for reaction handling
+        session.worktreePromptPostId = post.id;
+        this.registerPost(post.id, session.threadId);
+        // Stop typing while waiting for response
+        this.stopTyping(session);
+    }
     handleEvent(threadId, event) {
         const session = this.sessions.get(threadId);
         if (!session)
@@ -602,6 +735,12 @@ export class SessionManager {
         const session = this.getSessionByPost(postId);
         if (!session)
             return;
+        // Handle ❌ on worktree prompt (skip worktree, continue in main repo)
+        // Must be checked BEFORE cancel reaction handler since ❌ is also a cancel emoji
+        if (session.worktreePromptPostId === postId && emojiName === 'x') {
+            await this.handleWorktreeSkip(session.threadId, username);
+            return;
+        }
         // Handle cancel reactions (❌ or 🛑) on any post in the session
         if (isCancelEmoji(emojiName)) {
             await this.cancelSession(session.threadId, username);
@@ -911,7 +1050,34 @@ export class SessionManager {
         let content = session.pendingContent.replace(/\n{3,}/g, '\n\n').trim();
         // Mattermost has a 16,383 character limit for posts
         const MAX_POST_LENGTH = 16000; // Leave some margin
+        const CONTINUATION_THRESHOLD = 14000; // Start new message before we hit the limit
+        // Check if we need to start a new message due to length
+        if (session.currentPostId && content.length > CONTINUATION_THRESHOLD) {
+            // Finalize the current post with what we have up to the threshold
+            // Find a good break point (end of line) near the threshold
+            let breakPoint = content.lastIndexOf('\n', CONTINUATION_THRESHOLD);
+            if (breakPoint < CONTINUATION_THRESHOLD * 0.7) {
+                // If we can't find a good line break, just break at the threshold
+                breakPoint = CONTINUATION_THRESHOLD;
+            }
+            const firstPart = content.substring(0, breakPoint).trim() + '\n\n*... (continued below)*';
+            const remainder = content.substring(breakPoint).trim();
+            // Update the current post with the first part
+            await this.mattermost.updatePost(session.currentPostId, firstPart);
+            // Start a new post for the continuation
+            session.currentPostId = null;
+            session.pendingContent = remainder;
+            // Create the continuation post if there's content
+            if (remainder) {
+                const post = await this.mattermost.createPost('*(continued)*\n\n' + remainder, session.threadId);
+                session.currentPostId = post.id;
+                this.registerPost(post.id, session.threadId);
+            }
+            return;
+        }
+        // Normal case: content fits in current post
         if (content.length > MAX_POST_LENGTH) {
+            // Safety truncation if we somehow got content that's still too long
             content = content.substring(0, MAX_POST_LENGTH - 50) + '\n\n*... (truncated)*';
         }
         if (session.currentPostId) {
@@ -1369,6 +1535,11 @@ export class SessionManager {
             `| 📂 **Directory** | \`${shortDir}\` |`,
             `| 👤 **Started by** | @${session.startedBy} |`,
         ];
+        // Show worktree info if active
+        if (session.worktreeInfo) {
+            const shortRepoRoot = session.worktreeInfo.repoRoot.replace(process.env.HOME || '', '~');
+            rows.push(`| 🌿 **Worktree** | \`${session.worktreeInfo.branch}\` (from \`${shortRepoRoot}\`) |`);
+        }
         if (otherParticipants) {
             rows.push(`| 👥 **Participants** | ${otherParticipants} |`);
         }
@@ -1420,6 +1591,305 @@ export class SessionManager {
         };
         this.registerPost(post.id, threadId);
     }
+    // ---------------------------------------------------------------------------
+    // Worktree Management
+    // ---------------------------------------------------------------------------
+    /**
+     * Handle a worktree branch response from user.
+     * Called when user replies with a branch name to the worktree prompt.
+     */
+    async handleWorktreeBranchResponse(threadId, branchName, username) {
+        const session = this.sessions.get(threadId);
+        if (!session || !session.pendingWorktreePrompt)
+            return false;
+        // Only session owner can respond
+        if (session.startedBy !== username && !this.mattermost.isUserAllowed(username)) {
+            return false;
+        }
+        // Validate branch name
+        if (!isValidBranchName(branchName)) {
+            await this.mattermost.createPost(`❌ Invalid branch name: \`${branchName}\`. Please provide a valid git branch name.`, threadId);
+            return true; // We handled it, but need another response
+        }
+        // Create and switch to worktree
+        await this.createAndSwitchToWorktree(threadId, branchName, username);
+        return true;
+    }
+    /**
+     * Handle ❌ reaction on worktree prompt - skip worktree and continue in main repo.
+     */
+    async handleWorktreeSkip(threadId, username) {
+        const session = this.sessions.get(threadId);
+        if (!session || !session.pendingWorktreePrompt)
+            return;
+        // Only session owner can skip
+        if (session.startedBy !== username && !this.mattermost.isUserAllowed(username)) {
+            return;
+        }
+        // Update the prompt post
+        if (session.worktreePromptPostId) {
+            try {
+                await this.mattermost.updatePost(session.worktreePromptPostId, `✅ Continuing in main repo (skipped by @${username})`);
+            }
+            catch (err) {
+                console.error('  ⚠️ Failed to update worktree prompt:', err);
+            }
+        }
+        // Clear pending state
+        session.pendingWorktreePrompt = false;
+        session.worktreePromptPostId = undefined;
+        const queuedPrompt = session.queuedPrompt;
+        session.queuedPrompt = undefined;
+        // Persist updated state
+        this.persistSession(session);
+        // Now send the queued message to Claude
+        if (queuedPrompt && session.claude.isRunning()) {
+            session.claude.sendMessage(queuedPrompt);
+            this.startTyping(session);
+        }
+    }
+    /**
+     * Create a new worktree and switch the session to it.
+     */
+    async createAndSwitchToWorktree(threadId, branch, username) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // Only session owner or admins can manage worktrees
+        if (session.startedBy !== username && !this.mattermost.isUserAllowed(username)) {
+            await this.mattermost.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, threadId);
+            return;
+        }
+        // Check if we're in a git repo
+        const isRepo = await isGitRepository(session.workingDir);
+        if (!isRepo) {
+            await this.mattermost.createPost(`❌ Current directory is not a git repository`, threadId);
+            return;
+        }
+        // Get repo root
+        const repoRoot = await getRepositoryRoot(session.workingDir);
+        // Check if worktree already exists for this branch
+        const existing = await findWorktreeByBranch(repoRoot, branch);
+        if (existing && !existing.isMain) {
+            await this.mattermost.createPost(`⚠️ Worktree for branch \`${branch}\` already exists at \`${existing.path}\`. Use \`!worktree switch ${branch}\` to switch to it.`, threadId);
+            return;
+        }
+        const shortId = threadId.substring(0, 8);
+        console.log(`  🌿 Session (${shortId}…) creating worktree for branch ${branch}`);
+        // Generate worktree path
+        const worktreePath = getWorktreeDir(repoRoot, branch);
+        try {
+            // Create the worktree
+            await createWorktree(repoRoot, branch, worktreePath);
+            // Update the prompt post if it exists
+            if (session.worktreePromptPostId) {
+                try {
+                    await this.mattermost.updatePost(session.worktreePromptPostId, `✅ Created worktree for \`${branch}\``);
+                }
+                catch (err) {
+                    console.error('  ⚠️ Failed to update worktree prompt:', err);
+                }
+            }
+            // Clear pending state
+            const wasPending = session.pendingWorktreePrompt;
+            session.pendingWorktreePrompt = false;
+            session.worktreePromptPostId = undefined;
+            const queuedPrompt = session.queuedPrompt;
+            session.queuedPrompt = undefined;
+            // Store worktree info
+            session.worktreeInfo = {
+                repoRoot,
+                worktreePath,
+                branch,
+            };
+            // Update working directory
+            session.workingDir = worktreePath;
+            // If Claude is already running, restart it in the new directory
+            if (session.claude.isRunning()) {
+                this.stopTyping(session);
+                session.isRestarting = true;
+                session.claude.kill();
+                // Flush any pending content
+                await this.flush(session);
+                session.currentPostId = null;
+                session.pendingContent = '';
+                // Create new CLI with new working directory
+                const cliOptions = {
+                    workingDir: worktreePath,
+                    threadId: threadId,
+                    skipPermissions: this.skipPermissions || !session.forceInteractivePermissions,
+                    sessionId: session.claudeSessionId,
+                    resume: true,
+                    chrome: this.chromeEnabled,
+                };
+                session.claude = new ClaudeCli(cliOptions);
+                // Rebind event handlers
+                session.claude.on('event', (e) => this.handleEvent(threadId, e));
+                session.claude.on('exit', (code) => this.handleExit(threadId, code));
+                // Start the new CLI
+                session.claude.start();
+            }
+            // Update session header
+            await this.updateSessionHeader(session);
+            // Post confirmation
+            const shortWorktreePath = worktreePath.replace(process.env.HOME || '', '~');
+            await this.mattermost.createPost(`✅ **Created worktree** for branch \`${branch}\`\n📁 Working directory: \`${shortWorktreePath}\`\n*Claude Code restarted in the new worktree*`, threadId);
+            // Update activity and persist
+            session.lastActivityAt = new Date();
+            session.timeoutWarningPosted = false;
+            this.persistSession(session);
+            // If there was a queued prompt (from initial session start), send it now
+            if (wasPending && queuedPrompt && session.claude.isRunning()) {
+                session.claude.sendMessage(queuedPrompt);
+                this.startTyping(session);
+            }
+            console.log(`  🌿 Session (${shortId}…) switched to worktree ${branch} at ${shortWorktreePath}`);
+        }
+        catch (err) {
+            console.error(`  ❌ Failed to create worktree:`, err);
+            await this.mattermost.createPost(`❌ Failed to create worktree: ${err instanceof Error ? err.message : String(err)}`, threadId);
+        }
+    }
+    /**
+     * Switch to an existing worktree.
+     */
+    async switchToWorktree(threadId, branchOrPath, username) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // Only session owner or admins can manage worktrees
+        if (session.startedBy !== username && !this.mattermost.isUserAllowed(username)) {
+            await this.mattermost.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, threadId);
+            return;
+        }
+        // Get current repo root
+        const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+        // Find the worktree
+        const worktrees = await listWorktrees(repoRoot);
+        const target = worktrees.find(wt => wt.branch === branchOrPath ||
+            wt.path === branchOrPath ||
+            wt.path.endsWith(branchOrPath));
+        if (!target) {
+            await this.mattermost.createPost(`❌ Worktree not found: \`${branchOrPath}\`. Use \`!worktree list\` to see available worktrees.`, threadId);
+            return;
+        }
+        // Use changeDirectory logic to switch
+        await this.changeDirectory(threadId, target.path, username);
+        // Update worktree info
+        session.worktreeInfo = {
+            repoRoot,
+            worktreePath: target.path,
+            branch: target.branch,
+        };
+        // Update session header
+        await this.updateSessionHeader(session);
+        this.persistSession(session);
+    }
+    /**
+     * List all worktrees for the current repository.
+     */
+    async listWorktreesCommand(threadId, _username) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // Check if we're in a git repo
+        const isRepo = await isGitRepository(session.workingDir);
+        if (!isRepo) {
+            await this.mattermost.createPost(`❌ Current directory is not a git repository`, threadId);
+            return;
+        }
+        // Get repo root (either from worktree info or current dir)
+        const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+        const worktrees = await listWorktrees(repoRoot);
+        if (worktrees.length === 0) {
+            await this.mattermost.createPost(`📋 No worktrees found for this repository`, threadId);
+            return;
+        }
+        const shortRepoRoot = repoRoot.replace(process.env.HOME || '', '~');
+        let message = `📋 **Worktrees for** \`${shortRepoRoot}\`:\n\n`;
+        for (const wt of worktrees) {
+            const shortPath = wt.path.replace(process.env.HOME || '', '~');
+            const isCurrent = session.workingDir === wt.path;
+            const marker = isCurrent ? ' ← current' : '';
+            const label = wt.isMain ? '(main repository)' : '';
+            message += `• \`${wt.branch}\` → \`${shortPath}\` ${label}${marker}\n`;
+        }
+        await this.mattermost.createPost(message, threadId);
+    }
+    /**
+     * Remove a worktree.
+     */
+    async removeWorktreeCommand(threadId, branchOrPath, username) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // Only session owner or admins can manage worktrees
+        if (session.startedBy !== username && !this.mattermost.isUserAllowed(username)) {
+            await this.mattermost.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, threadId);
+            return;
+        }
+        // Get current repo root
+        const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+        // Find the worktree
+        const worktrees = await listWorktrees(repoRoot);
+        const target = worktrees.find(wt => wt.branch === branchOrPath ||
+            wt.path === branchOrPath ||
+            wt.path.endsWith(branchOrPath));
+        if (!target) {
+            await this.mattermost.createPost(`❌ Worktree not found: \`${branchOrPath}\`. Use \`!worktree list\` to see available worktrees.`, threadId);
+            return;
+        }
+        // Can't remove the main repository
+        if (target.isMain) {
+            await this.mattermost.createPost(`❌ Cannot remove the main repository. Use \`!worktree remove\` only for worktrees.`, threadId);
+            return;
+        }
+        // Can't remove the current working directory
+        if (session.workingDir === target.path) {
+            await this.mattermost.createPost(`❌ Cannot remove the current working directory. Switch to another worktree first.`, threadId);
+            return;
+        }
+        try {
+            await removeGitWorktree(repoRoot, target.path);
+            const shortPath = target.path.replace(process.env.HOME || '', '~');
+            await this.mattermost.createPost(`✅ Removed worktree \`${target.branch}\` at \`${shortPath}\``, threadId);
+            console.log(`  🗑️ Removed worktree ${target.branch} at ${shortPath}`);
+        }
+        catch (err) {
+            console.error(`  ❌ Failed to remove worktree:`, err);
+            await this.mattermost.createPost(`❌ Failed to remove worktree: ${err instanceof Error ? err.message : String(err)}`, threadId);
+        }
+    }
+    /**
+     * Disable worktree prompts for a session.
+     */
+    async disableWorktreePrompt(threadId, username) {
+        const session = this.sessions.get(threadId);
+        if (!session)
+            return;
+        // Only session owner or admins can manage worktrees
+        if (session.startedBy !== username && !this.mattermost.isUserAllowed(username)) {
+            await this.mattermost.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, threadId);
+            return;
+        }
+        session.worktreePromptDisabled = true;
+        this.persistSession(session);
+        await this.mattermost.createPost(`✅ Worktree prompts disabled for this session`, threadId);
+    }
+    /**
+     * Check if a session has a pending worktree prompt.
+     */
+    hasPendingWorktreePrompt(threadId) {
+        const session = this.sessions.get(threadId);
+        return session?.pendingWorktreePrompt === true;
+    }
+    /**
+     * Get the worktree prompt post ID for a session.
+     */
+    getWorktreePromptPostId(threadId) {
+        const session = this.sessions.get(threadId);
+        return session?.worktreePromptPostId;
+    }
     /** Kill all active sessions (for graceful shutdown) */
     killAllSessions() {
         console.log(`  [shutdown] killAllSessions called, isShuttingDown already=${this.isShuttingDown}`);

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 /** Check if any .env config file exists */
 export declare function configExists(): boolean;
+export type WorktreeMode = 'off' | 'prompt' | 'require';
 /** CLI arguments that can override config */
 export interface CliArgs {
     url?: string;
@@ -9,6 +10,7 @@ export interface CliArgs {
     allowedUsers?: string;
     skipPermissions?: boolean;
     chrome?: boolean;
+    worktreeMode?: WorktreeMode;
 }
 export interface Config {
     mattermost: {
@@ -20,5 +22,6 @@ export interface Config {
     allowedUsers: string[];
     skipPermissions: boolean;
     chrome: boolean;
+    worktreeMode: WorktreeMode;
 }
 export declare function loadConfig(cliArgs?: CliArgs): Config;

package/dist/config.js

@@ -65,6 +65,20 @@ export function loadConfig(cliArgs) {
     else {
         chrome = process.env.CLAUDE_CHROME === 'true';
     }
+    // Worktree mode: CLI flag or env var, default to 'prompt'
+    let worktreeMode;
+    if (cliArgs?.worktreeMode !== undefined) {
+        worktreeMode = cliArgs.worktreeMode;
+    }
+    else {
+        const envValue = process.env.WORKTREE_MODE?.toLowerCase();
+        if (envValue === 'off' || envValue === 'prompt' || envValue === 'require') {
+            worktreeMode = envValue;
+        }
+        else {
+            worktreeMode = 'prompt'; // Default
+        }
+    }
     return {
         mattermost: {
             url: url.replace(/\/$/, ''), // Remove trailing slash
@@ -75,5 +89,6 @@ export function loadConfig(cliArgs) {
         allowedUsers,
         skipPermissions,
         chrome,
+        worktreeMode,
     };
 }

package/dist/git/worktree.d.ts

@@ -0,0 +1,50 @@
+export interface WorktreeInfo {
+    path: string;
+    branch: string;
+    commit: string;
+    isMain: boolean;
+    isBare: boolean;
+}
+/**
+ * Check if a directory is inside a git repository
+ */
+export declare function isGitRepository(dir: string): Promise<boolean>;
+/**
+ * Get the root directory of the git repository
+ */
+export declare function getRepositoryRoot(dir: string): Promise<string>;
+/**
+ * Check if there are uncommitted changes (staged or unstaged)
+ */
+export declare function hasUncommittedChanges(dir: string): Promise<boolean>;
+/**
+ * List all worktrees for a repository
+ */
+export declare function listWorktrees(repoRoot: string): Promise<WorktreeInfo[]>;
+/**
+ * Check if a branch exists (local or remote)
+ */
+export declare function branchExists(repoRoot: string, branch: string): Promise<boolean>;
+/**
+ * Generate the worktree directory path
+ * Creates path like: /path/to/repo-worktrees/branch-name-abc123
+ */
+export declare function getWorktreeDir(repoRoot: string, branch: string): string;
+/**
+ * Create a new worktree for a branch
+ * If the branch doesn't exist, creates it from the current HEAD
+ */
+export declare function createWorktree(repoRoot: string, branch: string, targetDir: string): Promise<string>;
+/**
+ * Remove a worktree
+ */
+export declare function removeWorktree(repoRoot: string, worktreePath: string): Promise<void>;
+/**
+ * Find a worktree by branch name
+ */
+export declare function findWorktreeByBranch(repoRoot: string, branch: string): Promise<WorktreeInfo | null>;
+/**
+ * Validate a git branch name
+ * Based on git-check-ref-format rules
+ */
+export declare function isValidBranchName(name: string): boolean;

package/dist/git/worktree.js

@@ -0,0 +1,228 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+/**
+ * Execute a git command and return stdout
+ */
+async function execGit(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('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) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`git ${args.join(' ')} failed: ${stderr || stdout}`));
+            }
+        });
+        proc.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Check if a directory is inside a git repository
+ */
+export async function isGitRepository(dir) {
+    try {
+        await execGit(['rev-parse', '--git-dir'], dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the root directory of the git repository
+ */
+export async function getRepositoryRoot(dir) {
+    return execGit(['rev-parse', '--show-toplevel'], dir);
+}
+/**
+ * Check if there are uncommitted changes (staged or unstaged)
+ */
+export async function hasUncommittedChanges(dir) {
+    try {
+        // Check for staged changes
+        const staged = await execGit(['diff', '--cached', '--quiet'], dir).catch(() => 'changes');
+        if (staged === 'changes')
+            return true;
+        // Check for unstaged changes
+        const unstaged = await execGit(['diff', '--quiet'], dir).catch(() => 'changes');
+        if (unstaged === 'changes')
+            return true;
+        // Check for untracked files
+        const untracked = await execGit(['ls-files', '--others', '--exclude-standard'], dir);
+        return untracked.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List all worktrees for a repository
+ */
+export async function listWorktrees(repoRoot) {
+    const output = await execGit(['worktree', 'list', '--porcelain'], repoRoot);
+    const worktrees = [];
+    if (!output)
+        return worktrees;
+    // Parse porcelain output
+    // Format:
+    // worktree /path/to/worktree
+    // HEAD <commit>
+    // branch refs/heads/branch-name
+    // <blank line>
+    const blocks = output.split('\n\n').filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        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 ')) {
+                // refs/heads/branch-name -> branch-name
+                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, // First worktree is the main one
+                isBare: worktree.isBare || false,
+            });
+        }
+    }
+    return worktrees;
+}
+/**
+ * Check if a branch exists (local or remote)
+ */
+export async function branchExists(repoRoot, branch) {
+    try {
+        // Check local branches
+        await execGit(['rev-parse', '--verify', `refs/heads/${branch}`], repoRoot);
+        return true;
+    }
+    catch {
+        try {
+            // Check remote branches
+            await execGit(['rev-parse', '--verify', `refs/remotes/origin/${branch}`], repoRoot);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Generate the worktree directory path
+ * Creates path like: /path/to/repo-worktrees/branch-name-abc123
+ */
+export function getWorktreeDir(repoRoot, branch) {
+    const repoName = path.basename(repoRoot);
+    const parentDir = path.dirname(repoRoot);
+    const worktreesDir = path.join(parentDir, `${repoName}-worktrees`);
+    // Sanitize branch name for filesystem
+    const sanitizedBranch = branch
+        .replace(/\//g, '-')
+        .replace(/[^a-zA-Z0-9-_]/g, '');
+    const shortUuid = randomUUID().slice(0, 8);
+    return path.join(worktreesDir, `${sanitizedBranch}-${shortUuid}`);
+}
+/**
+ * Create a new worktree for a branch
+ * If the branch doesn't exist, creates it from the current HEAD
+ */
+export async function createWorktree(repoRoot, branch, targetDir) {
+    // Ensure the parent directory exists
+    const parentDir = path.dirname(targetDir);
+    await fs.mkdir(parentDir, { recursive: true });
+    // Check if branch exists
+    const exists = await branchExists(repoRoot, branch);
+    if (exists) {
+        // Use existing branch
+        await execGit(['worktree', 'add', targetDir, branch], repoRoot);
+    }
+    else {
+        // Create new branch from HEAD
+        await execGit(['worktree', 'add', '-b', branch, targetDir], repoRoot);
+    }
+    return targetDir;
+}
+/**
+ * Remove a worktree
+ */
+export async function removeWorktree(repoRoot, worktreePath) {
+    // First try to remove cleanly
+    try {
+        await execGit(['worktree', 'remove', worktreePath], repoRoot);
+    }
+    catch {
+        // If that fails, try force remove
+        await execGit(['worktree', 'remove', '--force', worktreePath], repoRoot);
+    }
+    // Prune any stale worktree references
+    await execGit(['worktree', 'prune'], repoRoot);
+}
+/**
+ * Find a worktree by branch name
+ */
+export async function findWorktreeByBranch(repoRoot, branch) {
+    const worktrees = await listWorktrees(repoRoot);
+    return worktrees.find((wt) => wt.branch === branch) || null;
+}
+/**
+ * Validate a git branch name
+ * Based on git-check-ref-format rules
+ */
+export function isValidBranchName(name) {
+    if (!name || name.length === 0)
+        return false;
+    // Cannot start or end with /
+    if (name.startsWith('/') || name.endsWith('/'))
+        return false;
+    // Cannot contain ..
+    if (name.includes('..'))
+        return false;
+    // Cannot contain special characters
+    if (/[\s~^:?*[\]\\]/.test(name))
+        return false;
+    // Cannot start with -
+    if (name.startsWith('-'))
+        return false;
+    // Cannot end with .lock
+    if (name.endsWith('.lock'))
+        return false;
+    // Cannot contain @{
+    if (name.includes('@{'))
+        return false;
+    // Cannot be @
+    if (name === '@')
+        return false;
+    // Cannot contain consecutive dots
+    if (/\.\./.test(name))
+        return false;
+    return true;
+}

package/dist/index.js

@@ -78,7 +78,7 @@ async function main() {
     }
     console.log('');
     const mattermost = new MattermostClient(config);
-    const session = new SessionManager(mattermost, workingDir, config.skipPermissions, config.chrome);
+    const session = new SessionManager(mattermost, workingDir, config.skipPermissions, config.chrome, config.worktreeMode);
     mattermost.on('message', async (post, user) => {
         try {
             const username = user?.username || 'unknown';
@@ -143,6 +143,11 @@ async function main() {
                         `| \`!cost\` | Show token usage and cost for this session |\n` +
                         `| \`!compact\` | Compress context to free up space |\n` +
                         `| \`!cd <path>\` | Change working directory (restarts Claude) |\n` +
+                        `| \`!worktree <branch>\` | Create and switch to a git worktree |\n` +
+                        `| \`!worktree list\` | List all worktrees for the repo |\n` +
+                        `| \`!worktree switch <branch>\` | Switch to an existing worktree |\n` +
+                        `| \`!worktree remove <branch>\` | Remove a worktree |\n` +
+                        `| \`!worktree off\` | Disable worktree prompts for this session |\n` +
                         `| \`!invite @user\` | Invite a user to this session |\n` +
                         `| \`!kick @user\` | Remove an invited user |\n` +
                         `| \`!permissions interactive\` | Enable interactive permissions |\n` +
@@ -197,6 +202,49 @@ async function main() {
                     await session.changeDirectory(threadRoot, cdMatch[1].trim(), username);
                     return;
                 }
+                // Check for !worktree command
+                const worktreeMatch = content.match(/^!worktree\s+(\S+)(?:\s+(.*))?$/i);
+                if (worktreeMatch) {
+                    const subcommand = worktreeMatch[1].toLowerCase();
+                    const args = worktreeMatch[2]?.trim();
+                    switch (subcommand) {
+                        case 'list':
+                            await session.listWorktreesCommand(threadRoot, username);
+                            break;
+                        case 'switch':
+                            if (!args) {
+                                await mattermost.createPost('❌ Usage: `!worktree switch <branch>`', threadRoot);
+                            }
+                            else {
+                                await session.switchToWorktree(threadRoot, args, username);
+                            }
+                            break;
+                        case 'remove':
+                            if (!args) {
+                                await mattermost.createPost('❌ Usage: `!worktree remove <branch>`', threadRoot);
+                            }
+                            else {
+                                await session.removeWorktreeCommand(threadRoot, args, username);
+                            }
+                            break;
+                        case 'off':
+                            await session.disableWorktreePrompt(threadRoot, username);
+                            break;
+                        default:
+                            // Treat as branch name: !worktree feature/foo
+                            await session.createAndSwitchToWorktree(threadRoot, subcommand, username);
+                    }
+                    return;
+                }
+                // Check for pending worktree prompt - treat message as branch name response
+                if (session.hasPendingWorktreePrompt(threadRoot)) {
+                    // Only session owner can respond
+                    if (session.isUserAllowedInSession(threadRoot, username)) {
+                        const handled = await session.handleWorktreeBranchResponse(threadRoot, content, username);
+                        if (handled)
+                            return;
+                    }
+                }
                 // Check for Claude Code slash commands (translate ! to /)
                 // These are sent directly to Claude Code as /commands
                 if (lowerContent === '!context' || lowerContent === '!cost' || lowerContent === '!compact') {
@@ -260,6 +308,15 @@ async function main() {
                 await mattermost.createPost(`Mention me with your request`, threadRoot);
                 return;
             }
+            // Check for inline branch syntax: "on branch X" or "!worktree X"
+            const branchMatch = prompt.match(/(?:on branch|!worktree)\s+(\S+)/i);
+            if (branchMatch) {
+                const branch = branchMatch[1];
+                // Remove the branch specification from the prompt
+                const cleanedPrompt = prompt.replace(/(?:on branch|!worktree)\s+\S+/i, '').trim();
+                await session.startSessionWithWorktree({ prompt: cleanedPrompt || prompt, files }, branch, username, threadRoot);
+                return;
+            }
             await session.startSession({ prompt, files }, username, threadRoot);
         }
         catch (err) {

package/dist/mcp/permission-server.js

@@ -28,7 +28,7 @@ import WebSocket from 'ws';
 import { isApprovalEmoji, isAllowAllEmoji, APPROVAL_EMOJIS, ALLOW_ALL_EMOJIS, DENIAL_EMOJIS } from '../mattermost/emoji.js';
 import { formatToolForPermission } from '../utils/tool-formatter.js';
 import { mcpLogger } from '../utils/logger.js';
-import { getMe, getUser, createInteractivePost, isUserAllowed, } from '../mattermost/api.js';
+import { getMe, getUser, createInteractivePost, updatePost, isUserAllowed, } from '../mattermost/api.js';
 // =============================================================================
 // Configuration
 // =============================================================================
@@ -151,17 +151,20 @@ async function handlePermission(toolName, toolInput) {
         const userId = await getBotUserId();
         const post = await createInteractivePost(apiConfig, MM_CHANNEL_ID, message, [APPROVAL_EMOJIS[0], ALLOW_ALL_EMOJIS[0], DENIAL_EMOJIS[0]], MM_THREAD_ID || undefined, userId);
         // Wait for user's reaction
-        const { emoji } = await waitForReaction(post.id);
+        const { emoji, username } = await waitForReaction(post.id);
         if (isApprovalEmoji(emoji)) {
+            await updatePost(apiConfig, post.id, `✅ **Allowed** by @${username}\n\n${toolInfo}`);
             mcpLogger.info(`Allowed: ${toolName}`);
             return { behavior: 'allow', updatedInput: toolInput };
         }
         else if (isAllowAllEmoji(emoji)) {
             allowAllSession = true;
+            await updatePost(apiConfig, post.id, `✅ **Allowed all** by @${username}\n\n${toolInfo}`);
             mcpLogger.info(`Allowed all: ${toolName}`);
             return { behavior: 'allow', updatedInput: toolInput };
         }
         else {
+            await updatePost(apiConfig, post.id, `❌ **Denied** by @${username}\n\n${toolInfo}`);
             mcpLogger.info(`Denied: ${toolName}`);
             return { behavior: 'deny', message: 'User denied permission' };
         }

package/dist/persistence/session-store.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Worktree information for a session
+ */
+export interface WorktreeInfo {
+    repoRoot: string;
+    worktreePath: string;
+    branch: string;
+}
 /**
  * Persisted session state for resuming after bot restart
  */
@@ -14,6 +22,10 @@ export interface PersistedSession {
     tasksPostId: string | null;
     lastActivityAt: string;
     planApproved: boolean;
+    worktreeInfo?: WorktreeInfo;
+    pendingWorktreePrompt?: boolean;
+    worktreePromptDisabled?: boolean;
+    queuedPrompt?: string;
 }
 /**
  * SessionStore - Persistence layer for session state

package/package.json

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