claude-threads 0.13.0 → 0.14.1

package/dist/session/worktree.js

@@ -0,0 +1,339 @@
+/**
+ * Git worktree management utilities
+ *
+ * Handles worktree prompts, creation, switching, and cleanup.
+ */
+import { isGitRepository, getRepositoryRoot, hasUncommittedChanges, listWorktrees as listGitWorktrees, createWorktree as createGitWorktree, removeWorktree as removeGitWorktree, getWorktreeDir, findWorktreeByBranch, isValidBranchName, } from '../git/worktree.js';
+import { ClaudeCli } from '../claude/cli.js';
+import { randomUUID } from 'crypto';
+/**
+ * Check if we should prompt the user to create a worktree.
+ * Returns the reason for prompting, or null if we shouldn't prompt.
+ */
+export async function shouldPromptForWorktree(session, worktreeMode, hasOtherSessionInRepo) {
+    // Skip if worktree mode is off
+    if (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 (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 = hasOtherSessionInRepo(repoRoot, session.threadId);
+    if (hasConcurrent)
+        return 'concurrent';
+    return null;
+}
+/**
+ * Post the worktree prompt message to the user.
+ */
+export async function postWorktreePrompt(session, reason, registerPost) {
+    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)
+    // Use 'x' emoji name, not Unicode ❌ character
+    const reactionOptions = reason === 'require' ? [] : ['x'];
+    const post = await session.platform.createInteractivePost(message, reactionOptions, session.threadId);
+    // Track the post for reaction handling
+    session.worktreePromptPostId = post.id;
+    registerPost(post.id, session.threadId);
+}
+/**
+ * Handle user providing a branch name in response to worktree prompt.
+ * Returns true if handled (whether successful or not).
+ */
+export async function handleWorktreeBranchResponse(session, branchName, username, createAndSwitch) {
+    if (!session.pendingWorktreePrompt)
+        return false;
+    // Only session owner can respond
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        return false;
+    }
+    // Validate branch name
+    if (!isValidBranchName(branchName)) {
+        await session.platform.createPost(`❌ Invalid branch name: \`${branchName}\`. Please provide a valid git branch name.`, session.threadId);
+        return true; // We handled it, but need another response
+    }
+    // Create and switch to worktree
+    await createAndSwitch(session.threadId, branchName, username);
+    return true;
+}
+/**
+ * Handle ❌ reaction on worktree prompt - skip worktree and continue in main repo.
+ */
+export async function handleWorktreeSkip(session, username, persistSession, startTyping) {
+    if (!session.pendingWorktreePrompt)
+        return;
+    // Only session owner can skip
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        return;
+    }
+    // Update the prompt post
+    if (session.worktreePromptPostId) {
+        try {
+            await session.platform.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
+    persistSession(session);
+    // Now send the queued message to Claude
+    if (queuedPrompt && session.claude.isRunning()) {
+        session.claude.sendMessage(queuedPrompt);
+        startTyping(session);
+    }
+}
+/**
+ * Create a new worktree and switch the session to it.
+ */
+export async function createAndSwitchToWorktree(session, branch, username, options) {
+    // Only session owner or admins can manage worktrees
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, session.threadId);
+        return;
+    }
+    // Check if we're in a git repo
+    const isRepo = await isGitRepository(session.workingDir);
+    if (!isRepo) {
+        await session.platform.createPost(`❌ Current directory is not a git repository`, session.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 session.platform.createPost(`⚠️ Worktree for branch \`${branch}\` already exists at \`${existing.path}\`. Use \`!worktree switch ${branch}\` to switch to it.`, session.threadId);
+        return;
+    }
+    const shortId = session.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 createGitWorktree(repoRoot, branch, worktreePath);
+        // Update the prompt post if it exists
+        if (session.worktreePromptPostId) {
+            try {
+                await session.platform.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()) {
+            options.stopTyping(session);
+            session.isRestarting = true;
+            session.claude.kill();
+            // Flush any pending content
+            await options.flush(session);
+            session.currentPostId = null;
+            session.pendingContent = '';
+            // Generate new session ID for fresh start in new directory
+            // (Claude CLI sessions are tied to working directory, can't resume across directories)
+            const newSessionId = randomUUID();
+            session.claudeSessionId = newSessionId;
+            // Create new CLI with new working directory
+            const cliOptions = {
+                workingDir: worktreePath,
+                threadId: session.threadId,
+                skipPermissions: options.skipPermissions || !session.forceInteractivePermissions,
+                sessionId: newSessionId,
+                resume: false, // Fresh start - can't resume across directories
+                chrome: options.chromeEnabled,
+                platformConfig: session.platform.getMcpConfig(),
+            };
+            session.claude = new ClaudeCli(cliOptions);
+            // Rebind event handlers (use sessionId which is the composite key)
+            session.claude.on('event', (e) => options.handleEvent(session.sessionId, e));
+            session.claude.on('exit', (code) => options.handleExit(session.sessionId, code));
+            // Start the new CLI
+            session.claude.start();
+        }
+        // Update session header
+        await options.updateSessionHeader(session);
+        // Post confirmation
+        const shortWorktreePath = worktreePath.replace(process.env.HOME || '', '~');
+        await session.platform.createPost(`✅ **Created worktree** for branch \`${branch}\`\n📁 Working directory: \`${shortWorktreePath}\`\n*Claude Code restarted in the new worktree*`, session.threadId);
+        // Update activity and persist
+        session.lastActivityAt = new Date();
+        session.timeoutWarningPosted = false;
+        options.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);
+            options.startTyping(session);
+        }
+        console.log(`  🌿 Session (${shortId}…) switched to worktree ${branch} at ${shortWorktreePath}`);
+    }
+    catch (err) {
+        console.error(`  ❌ Failed to create worktree:`, err);
+        await session.platform.createPost(`❌ Failed to create worktree: ${err instanceof Error ? err.message : String(err)}`, session.threadId);
+    }
+}
+/**
+ * Switch to an existing worktree.
+ */
+export async function switchToWorktree(session, branchOrPath, username, changeDirectory) {
+    // Only session owner or admins can manage worktrees
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, session.threadId);
+        return;
+    }
+    // Get current repo root
+    const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+    // Find the worktree
+    const worktrees = await listGitWorktrees(repoRoot);
+    const target = worktrees.find(wt => wt.branch === branchOrPath ||
+        wt.path === branchOrPath ||
+        wt.path.endsWith(branchOrPath));
+    if (!target) {
+        await session.platform.createPost(`❌ Worktree not found: \`${branchOrPath}\`. Use \`!worktree list\` to see available worktrees.`, session.threadId);
+        return;
+    }
+    // Use changeDirectory logic to switch
+    await changeDirectory(session.threadId, target.path, username);
+    // Update worktree info
+    session.worktreeInfo = {
+        repoRoot,
+        worktreePath: target.path,
+        branch: target.branch,
+    };
+}
+/**
+ * List all worktrees for the current repository.
+ */
+export async function listWorktreesCommand(session) {
+    // Check if we're in a git repo
+    const isRepo = await isGitRepository(session.workingDir);
+    if (!isRepo) {
+        await session.platform.createPost(`❌ Current directory is not a git repository`, session.threadId);
+        return;
+    }
+    // Get repo root (either from worktree info or current dir)
+    const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+    const worktrees = await listGitWorktrees(repoRoot);
+    if (worktrees.length === 0) {
+        await session.platform.createPost(`📋 No worktrees found for this repository`, session.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 session.platform.createPost(message, session.threadId);
+}
+/**
+ * Remove a worktree.
+ */
+export async function removeWorktreeCommand(session, branchOrPath, username) {
+    // Only session owner or admins can manage worktrees
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, session.threadId);
+        return;
+    }
+    // Get current repo root
+    const repoRoot = session.worktreeInfo?.repoRoot || await getRepositoryRoot(session.workingDir);
+    // Find the worktree
+    const worktrees = await listGitWorktrees(repoRoot);
+    const target = worktrees.find(wt => wt.branch === branchOrPath ||
+        wt.path === branchOrPath ||
+        wt.path.endsWith(branchOrPath));
+    if (!target) {
+        await session.platform.createPost(`❌ Worktree not found: \`${branchOrPath}\`. Use \`!worktree list\` to see available worktrees.`, session.threadId);
+        return;
+    }
+    // Can't remove the main repository
+    if (target.isMain) {
+        await session.platform.createPost(`❌ Cannot remove the main repository. Use \`!worktree remove\` only for worktrees.`, session.threadId);
+        return;
+    }
+    // Can't remove the current working directory
+    if (session.workingDir === target.path) {
+        await session.platform.createPost(`❌ Cannot remove the current working directory. Switch to another worktree first.`, session.threadId);
+        return;
+    }
+    try {
+        await removeGitWorktree(repoRoot, target.path);
+        const shortPath = target.path.replace(process.env.HOME || '', '~');
+        await session.platform.createPost(`✅ Removed worktree \`${target.branch}\` at \`${shortPath}\``, session.threadId);
+        console.log(`  🗑️ Removed worktree ${target.branch} at ${shortPath}`);
+    }
+    catch (err) {
+        console.error(`  ❌ Failed to remove worktree:`, err);
+        await session.platform.createPost(`❌ Failed to remove worktree: ${err instanceof Error ? err.message : String(err)}`, session.threadId);
+    }
+}
+/**
+ * Disable worktree prompts for a session.
+ */
+export async function disableWorktreePrompt(session, username, persistSession) {
+    // Only session owner or admins can manage worktrees
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can manage worktrees`, session.threadId);
+        return;
+    }
+    session.worktreePromptDisabled = true;
+    persistSession(session);
+    await session.platform.createPost(`✅ Worktree prompts disabled for this session`, session.threadId);
+}

package/dist/update-notifier.js

@@ -2,6 +2,7 @@ import updateNotifier from 'update-notifier';
 import { readFileSync } from 'fs';
 import { resolve } from 'path';
 import { fileURLToPath } from 'url';
+import semver from 'semver';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 let cachedUpdateInfo;
 export function checkForUpdates() {
@@ -26,6 +27,15 @@ Run: npm install -g claude-threads`,
     }
 }
 // Returns update info if available, for posting to Mattermost
+// Only returns if latest > current (handles stale cache edge case)
 export function getUpdateInfo() {
+    if (!cachedUpdateInfo)
+        return undefined;
+    // Sanity check: only show update if latest is actually newer
+    const current = cachedUpdateInfo.current;
+    const latest = cachedUpdateInfo.latest;
+    if (current && latest && semver.gte(current, latest)) {
+        return undefined; // Current is same or newer, no update needed
+    }
     return cachedUpdateInfo;
 }

package/dist/{mattermost → utils}/emoji.d.ts

@@ -1,8 +1,8 @@
 /**
- * Emoji constants and helpers for Mattermost reactions
+ * Emoji constants and helpers for chat platform reactions
  *
- * Centralized place for all emoji-related logic to avoid duplication
- * across session.ts and permission-server.ts
+ * Platform-agnostic emoji utilities used across session management,
+ * permission handling, and user interactions.
  */
 /** Emoji names that indicate approval */
 export declare const APPROVAL_EMOJIS: readonly ["+1", "thumbsup"];

package/dist/{mattermost → utils}/emoji.js

@@ -1,8 +1,8 @@
 /**
- * Emoji constants and helpers for Mattermost reactions
+ * Emoji constants and helpers for chat platform reactions
  *
- * Centralized place for all emoji-related logic to avoid duplication
- * across session.ts and permission-server.ts
+ * Platform-agnostic emoji utilities used across session management,
+ * permission handling, and user interactions.
  */
 /** Emoji names that indicate approval */
 export const APPROVAL_EMOJIS = ['+1', 'thumbsup'];

package/dist/utils/emoji.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/tool-formatter.d.ts

@@ -1,10 +1,14 @@
 /**
- * Tool formatting utilities for displaying Claude tool calls in Mattermost
+ * Tool formatting utilities for displaying Claude tool calls in chat platforms
  *
  * This module provides shared formatting logic used by both:
- * - src/claude/session.ts (main bot)
+ * - src/session/events.ts (main bot)
  * - src/mcp/permission-server.ts (MCP permission handler)
+ *
+ * Uses PlatformFormatter abstraction to support different markdown dialects
+ * (e.g., Mattermost standard markdown vs Slack mrkdwn).
  */
+import type { PlatformFormatter } from '../platform/formatter.js';
 export interface ToolInput {
     [key: string]: unknown;
 }
@@ -30,27 +34,20 @@ export declare function parseMcpToolName(toolName: string): {
     tool: string;
 } | null;
 /**
- * Format a tool use for display in Mattermost
+ * Format a tool use for display in chat platforms
  *
  * @param toolName - The name of the tool being called
  * @param input - The tool input parameters
  * @param options - Formatting options
  * @returns Formatted string or null if the tool should not be displayed
  */
-export declare function formatToolUse(toolName: string, input: ToolInput, options?: FormatOptions): string | null;
+export declare function formatToolUse(toolName: string, input: ToolInput, formatter: PlatformFormatter, options?: FormatOptions): string | null;
 /**
  * Format tool info for permission prompts (simpler format)
  *
  * @param toolName - The name of the tool
  * @param input - The tool input parameters
+ * @param formatter - Platform-specific markdown formatter
  * @returns Formatted string for permission prompts
  */
-export declare function formatToolForPermission(toolName: string, input: ToolInput): string;
-/**
- * Format Claude in Chrome tool calls
- *
- * @param tool - The Chrome tool name (after mcp__claude-in-chrome__)
- * @param input - The tool input parameters
- * @returns Formatted string for display
- */
-export declare function formatChromeToolUse(tool: string, input: ToolInput): string;
+export declare function formatToolForPermission(toolName: string, input: ToolInput, formatter: PlatformFormatter): string;

package/dist/utils/tool-formatter.js

@@ -1,9 +1,12 @@
 /**
- * Tool formatting utilities for displaying Claude tool calls in Mattermost
+ * Tool formatting utilities for displaying Claude tool calls in chat platforms
  *
  * This module provides shared formatting logic used by both:
- * - src/claude/session.ts (main bot)
+ * - src/session/events.ts (main bot)
  * - src/mcp/permission-server.ts (MCP permission handler)
+ *
+ * Uses PlatformFormatter abstraction to support different markdown dialects
+ * (e.g., Mattermost standard markdown vs Slack mrkdwn).
  */
 import * as Diff from 'diff';
 const DEFAULT_OPTIONS = {
@@ -39,19 +42,19 @@ export function parseMcpToolName(toolName) {
     };
 }
 /**
- * Format a tool use for display in Mattermost
+ * Format a tool use for display in chat platforms
  *
  * @param toolName - The name of the tool being called
  * @param input - The tool input parameters
  * @param options - Formatting options
  * @returns Formatted string or null if the tool should not be displayed
  */
-export function formatToolUse(toolName, input, options = {}) {
+export function formatToolUse(toolName, input, formatter, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const short = (p) => shortenPath(p);
     switch (toolName) {
         case 'Read':
-            return `📄 **Read** \`${short(input.file_path)}\``;
+            return `📄 ${formatter.formatBold('Read')} ${formatter.formatCode(short(input.file_path))}`;
         case 'Edit': {
             const filePath = short(input.file_path);
             const oldStr = input.old_string || '';
@@ -84,15 +87,14 @@ export function formatToolUse(toolName, input, options = {}) {
                         break;
                 }
                 const totalLines = changes.reduce((sum, c) => sum + c.value.split('\n').length - 1, 0);
-                let diff = `✏️ **Edit** \`${filePath}\`\n\`\`\`diff\n`;
-                diff += diffLines.join('\n');
+                let diff = `✏️ ${formatter.formatBold('Edit')} ${formatter.formatCode(filePath)}\n${formatter.formatCodeBlock(diffLines.join('\n'), 'diff')}`;
                 if (totalLines > maxLines) {
-                    diff += `\n... (+${totalLines - maxLines} more lines)`;
+                    diff = `✏️ ${formatter.formatBold('Edit')} ${formatter.formatCode(filePath)}\n`;
+                    diff += formatter.formatCodeBlock(diffLines.join('\n') + `\n... (+${totalLines - maxLines} more lines)`, 'diff');
                 }
-                diff += '\n```';
                 return diff;
             }
-            return `✏️ **Edit** \`${filePath}\``;
+            return `✏️ ${formatter.formatBold('Edit')} ${formatter.formatCode(filePath)}`;
         }
         case 'Write': {
             const filePath = short(input.file_path);
@@ -103,29 +105,30 @@ export function formatToolUse(toolName, input, options = {}) {
             if (opts.detailed && content && lineCount > 0) {
                 const maxLines = 6;
                 const previewLines = lines.slice(0, maxLines);
-                let preview = `📝 **Write** \`${filePath}\` *(${lineCount} lines)*\n\`\`\`\n`;
-                preview += previewLines.join('\n');
+                let preview = `📝 ${formatter.formatBold('Write')} ${formatter.formatCode(filePath)} ${formatter.formatItalic(`(${lineCount} lines)`)}\n`;
                 if (lineCount > maxLines) {
-                    preview += `\n... (${lineCount - maxLines} more lines)`;
+                    preview += formatter.formatCodeBlock(previewLines.join('\n') + `\n... (${lineCount - maxLines} more lines)`);
+                }
+                else {
+                    preview += formatter.formatCodeBlock(previewLines.join('\n'));
                 }
-                preview += '\n```';
                 return preview;
             }
-            return `📝 **Write** \`${filePath}\``;
+            return `📝 ${formatter.formatBold('Write')} ${formatter.formatCode(filePath)}`;
         }
         case 'Bash': {
             const cmd = (input.command || '').substring(0, opts.maxCommandLength);
             const truncated = cmd.length >= opts.maxCommandLength;
-            return `💻 **Bash** \`${cmd}${truncated ? '...' : ''}\``;
+            return `💻 ${formatter.formatBold('Bash')} ${formatter.formatCode(cmd + (truncated ? '...' : ''))}`;
         }
         case 'Glob':
-            return `🔍 **Glob** \`${input.pattern}\``;
+            return `🔍 ${formatter.formatBold('Glob')} ${formatter.formatCode(input.pattern)}`;
         case 'Grep':
-            return `🔎 **Grep** \`${input.pattern}\``;
+            return `🔎 ${formatter.formatBold('Grep')} ${formatter.formatCode(input.pattern)}`;
         case 'Task':
             return null; // Handled specially with subagent display
         case 'EnterPlanMode':
-            return `📋 **Planning...**`;
+            return `📋 ${formatter.formatBold('Planning...')}`;
         case 'ExitPlanMode':
             return null; // Handled specially with approval buttons
         case 'AskUserQuestion':
@@ -134,21 +137,21 @@ export function formatToolUse(toolName, input, options = {}) {
             return null; // Handled specially with task list display
         case 'WebFetch': {
             const url = (input.url || '').substring(0, 40);
-            return `🌐 **Fetching** \`${url}\``;
+            return `🌐 ${formatter.formatBold('Fetching')} ${formatter.formatCode(url)}`;
         }
         case 'WebSearch':
-            return `🔍 **Searching** \`${input.query}\``;
+            return `🔍 ${formatter.formatBold('Searching')} ${formatter.formatCode(input.query)}`;
         default: {
             // Handle MCP tools: mcp__server__tool
             const mcpParts = parseMcpToolName(toolName);
             if (mcpParts) {
                 // Special formatting for Claude in Chrome tools
                 if (mcpParts.server === 'claude-in-chrome') {
-                    return formatChromeToolUse(mcpParts.tool, input);
+                    return formatChromeToolUse(mcpParts.tool, input, formatter);
                 }
-                return `🔌 **${mcpParts.tool}** *(${mcpParts.server})*`;
+                return `🔌 ${formatter.formatBold(mcpParts.tool)} ${formatter.formatItalic(`(${mcpParts.server})`)}`;
             }
-            return `● **${toolName}**`;
+            return `● ${formatter.formatBold(toolName)}`;
         }
     }
 }
@@ -157,27 +160,28 @@ export function formatToolUse(toolName, input, options = {}) {
  *
  * @param toolName - The name of the tool
  * @param input - The tool input parameters
+ * @param formatter - Platform-specific markdown formatter
  * @returns Formatted string for permission prompts
  */
-export function formatToolForPermission(toolName, input) {
+export function formatToolForPermission(toolName, input, formatter) {
     const short = (p) => shortenPath(p);
     switch (toolName) {
         case 'Read':
-            return `📄 **Read** \`${short(input.file_path)}\``;
+            return `📄 ${formatter.formatBold('Read')} ${formatter.formatCode(short(input.file_path))}`;
         case 'Write':
-            return `📝 **Write** \`${short(input.file_path)}\``;
+            return `📝 ${formatter.formatBold('Write')} ${formatter.formatCode(short(input.file_path))}`;
         case 'Edit':
-            return `✏️ **Edit** \`${short(input.file_path)}\``;
+            return `✏️ ${formatter.formatBold('Edit')} ${formatter.formatCode(short(input.file_path))}`;
         case 'Bash': {
             const cmd = (input.command || '').substring(0, 100);
-            return `💻 **Bash** \`${cmd}${cmd.length >= 100 ? '...' : ''}\``;
+            return `💻 ${formatter.formatBold('Bash')} ${formatter.formatCode(cmd + (cmd.length >= 100 ? '...' : ''))}`;
         }
         default: {
             const mcpParts = parseMcpToolName(toolName);
             if (mcpParts) {
-                return `🔌 **${mcpParts.tool}** *(${mcpParts.server})*`;
+                return `🔌 ${formatter.formatBold(mcpParts.tool)} ${formatter.formatItalic(`(${mcpParts.server})`)}`;
             }
-            return `● **${toolName}**`;
+            return `● ${formatter.formatBold(toolName)}`;
         }
     }
 }
@@ -186,9 +190,10 @@ export function formatToolForPermission(toolName, input) {
  *
  * @param tool - The Chrome tool name (after mcp__claude-in-chrome__)
  * @param input - The tool input parameters
+ * @param formatter - Platform-specific markdown formatter
  * @returns Formatted string for display
  */
-export function formatChromeToolUse(tool, input) {
+function formatChromeToolUse(tool, input, formatter) {
     const action = input.action || '';
     const coord = input.coordinate;
     const url = input.url || '';
@@ -221,27 +226,27 @@ export function formatChromeToolUse(tool, input) {
                 default:
                     detail = action || 'action';
             }
-            return `🌐 **Chrome**[computer] \`${detail}\``;
+            return `🌐 ${formatter.formatBold('Chrome')}[computer] ${formatter.formatCode(detail)}`;
         }
         case 'navigate':
-            return `🌐 **Chrome**[navigate] \`${url.substring(0, 50)}${url.length > 50 ? '...' : ''}\``;
+            return `🌐 ${formatter.formatBold('Chrome')}[navigate] ${formatter.formatCode(url.substring(0, 50) + (url.length > 50 ? '...' : ''))}`;
         case 'tabs_context_mcp':
-            return `🌐 **Chrome**[tabs] reading context`;
+            return `🌐 ${formatter.formatBold('Chrome')}[tabs] reading context`;
         case 'tabs_create_mcp':
-            return `🌐 **Chrome**[tabs] creating new tab`;
+            return `🌐 ${formatter.formatBold('Chrome')}[tabs] creating new tab`;
         case 'read_page':
-            return `🌐 **Chrome**[read_page] ${input.filter === 'interactive' ? 'interactive elements' : 'accessibility tree'}`;
+            return `🌐 ${formatter.formatBold('Chrome')}[read_page] ${input.filter === 'interactive' ? 'interactive elements' : 'accessibility tree'}`;
         case 'find':
-            return `🌐 **Chrome**[find] \`${input.query || ''}\``;
+            return `🌐 ${formatter.formatBold('Chrome')}[find] ${formatter.formatCode(input.query || '')}`;
         case 'form_input':
-            return `🌐 **Chrome**[form_input] setting value`;
+            return `🌐 ${formatter.formatBold('Chrome')}[form_input] setting value`;
         case 'get_page_text':
-            return `🌐 **Chrome**[get_page_text] extracting content`;
+            return `🌐 ${formatter.formatBold('Chrome')}[get_page_text] extracting content`;
         case 'javascript_tool':
-            return `🌐 **Chrome**[javascript] executing script`;
+            return `🌐 ${formatter.formatBold('Chrome')}[javascript] executing script`;
         case 'gif_creator':
-            return `🌐 **Chrome**[gif] ${action}`;
+            return `🌐 ${formatter.formatBold('Chrome')}[gif] ${action}`;
         default:
-            return `🌐 **Chrome**[${tool}]`;
+            return `🌐 ${formatter.formatBold('Chrome')}[${tool}]`;
     }
 }