claude-threads 0.49.0 → 0.51.0

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.51.0] - 2026-01-09
+
+### Added
+- **Image upload for bug reports** - Bug reports can now include screenshots uploaded to Catbox.moe. Use `!bug <description>` with an attached image or paste a screenshot (#153)
+
+### Fixed
+- **Duplicate task lists** - Fixed issue where multiple task lists would appear in threads due to race conditions (#152, #151)
+- **Code block rendering** - Fixed issues with code blocks not rendering correctly, including improved handling of language tags and empty blocks (#154)
+- **Website logo rendering** - Improved SVG logo rendering on the project website (#155)
+
+## [0.50.0] - 2026-01-09
+
+### Added
+- **Bug reporting feature** - Users can now report bugs with `!bug <description>` command. The bot collects recent conversation context, session state, and system info into a markdown report posted as a file attachment (#150)
+
 ## [0.49.0] - 2026-01-09
 
 ### Added

package/README.md

@@ -6,6 +6,10 @@
  ✴ ▀█▄  █  ✴
 ```
 
+<p align="center">
+  <a href="https://claude-threads.run"><strong>claude-threads.run</strong></a>
+</p>
+
 [![npm version](https://img.shields.io/npm/v/claude-threads.svg)](https://www.npmjs.com/package/claude-threads)
 [![npm downloads](https://img.shields.io/npm/dm/claude-threads.svg)](https://www.npmjs.com/package/claude-threads)
 [![CI](https://github.com/anneschuth/claude-threads/actions/workflows/ci.yml/badge.svg)](https://github.com/anneschuth/claude-threads/actions/workflows/ci.yml)

package/dist/index.js

@@ -42763,9 +42763,11 @@ ${code}
 `);
   }
   formatMarkdown(content) {
-    return content.replace(/\n{3,}/g, `
+    let processed = content.replace(/(?<=\n)```(?=\S)(?![a-zA-Z]*\n)/g, "```\n");
+    processed = processed.replace(/\n{3,}/g, `
 
 `);
+    return processed;
   }
 }
 
@@ -43407,6 +43409,7 @@ function convertMarkdownToSlack(content) {
   for (let i = 0;i < codeBlocks.length; i++) {
     preserved = preserved.replace(`${CODE_BLOCK_PLACEHOLDER}${i}\x00`, codeBlocks[i]);
   }
+  preserved = preserved.replace(/(?<=\n)```(?=\S)(?![a-zA-Z]*\n)/g, "```\n");
   return preserved;
 }
 function convertMarkdownTablesToSlack(content) {
@@ -44639,7 +44642,7 @@ class SlackPermissionApi {
 import { EventEmitter as EventEmitter4 } from "events";
 import { existsSync as existsSync9 } from "fs";
 import { readdir, rm } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/persistence/session-store.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "fs";
@@ -44894,6 +44897,7 @@ var CANCEL_EMOJIS = ["x", "octagonal_sign", "stop_sign", "stop"];
 var ESCAPE_EMOJIS = ["double_vertical_bar", "pause_button", "pause"];
 var RESUME_EMOJIS = ["arrows_counterclockwise", "arrow_forward", "repeat"];
 var TASK_TOGGLE_EMOJIS = ["arrow_down_small", "small_red_triangle_down"];
+var BUG_REPORT_EMOJI = "bug";
 function isApprovalEmoji(emoji) {
   return APPROVAL_EMOJIS.includes(emoji);
 }
@@ -44915,6 +44919,9 @@ function isResumeEmoji(emoji) {
 function isTaskToggleEmoji(emoji) {
   return TASK_TOGGLE_EMOJIS.includes(emoji);
 }
+function isBugReportEmoji(emoji) {
+  return emoji === BUG_REPORT_EMOJI || emoji === "\uD83D\uDC1B";
+}
 var UNICODE_NUMBER_EMOJIS = {
   "1\uFE0F\u20E3": 0,
   "2\uFE0F\u20E3": 1,
@@ -45284,8 +45291,19 @@ async function postSuccess(session, message) {
 async function postWarning(session, message) {
   return createPostAndTrack(session, `\u26A0\uFE0F ${message}`);
 }
-async function postError(session, message) {
-  return createPostAndTrack(session, `\u274C ${message}`);
+async function postError(session, message, addBugReaction = true) {
+  const post = await createPostAndTrack(session, `\u274C ${message}`);
+  if (addBugReaction) {
+    try {
+      await session.platform.addReaction(post.id, BUG_REPORT_EMOJI);
+      session.lastError = {
+        postId: post.id,
+        message,
+        timestamp: new Date
+      };
+    } catch {}
+  }
+  return post;
 }
 async function postSecure(session, message) {
   return createPostAndTrack(session, `\uD83D\uDD10 ${message}`);
@@ -46388,14 +46406,15 @@ function formatToolUse(toolName, input, formatter, options = {}) {
           for (const line of lines) {
             if (lineCount >= maxLines)
               break;
+            const escapedLine = line.replace(/```/g, "` ``");
             if (change.added) {
-              diffLines2.push(`+ ${line}`);
+              diffLines2.push(`+ ${escapedLine}`);
               lineCount++;
             } else if (change.removed) {
-              diffLines2.push(`- ${line}`);
+              diffLines2.push(`- ${escapedLine}`);
               lineCount++;
             } else {
-              diffLines2.push(`  ${line}`);
+              diffLines2.push(`  ${escapedLine}`);
               lineCount++;
             }
           }
@@ -46426,7 +46445,7 @@ ${formatter.formatCodeBlock(diffLines2.join(`
       const lineCount = lines.length;
       if (detailed && content && lineCount > 0) {
         const maxLines = 6;
-        const previewLines = lines.slice(0, maxLines);
+        const previewLines = lines.slice(0, maxLines).map((line) => line.replace(/```/g, "` ``"));
         let preview = `\uD83D\uDCDD ${formatter.formatBold("Write")} ${formatter.formatCode(filePath)} ${formatter.formatItalic(`(${lineCount} lines)`)}
 `;
         if (lineCount > maxLines) {
@@ -50488,6 +50507,353 @@ function getLogo(version) {
 \`\`\``;
 }
 
+// src/session/bug-report.ts
+import { execSync as execSync2 } from "child_process";
+import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+
+// src/claude/version-check.ts
+var import_semver3 = __toESM(require_semver2(), 1);
+import { execSync } from "child_process";
+var CLAUDE_CLI_VERSION_RANGE = ">=2.0.74 <2.2.0";
+function getClaudeCliVersion() {
+  const claudePath = process.env.CLAUDE_PATH || "claude";
+  try {
+    const output = execSync(`${claudePath} --version`, {
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = output.match(/^([\d.]+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function isVersionCompatible(version) {
+  const semverVersion = import_semver3.coerce(version);
+  if (!semverVersion)
+    return false;
+  return import_semver3.satisfies(semverVersion, CLAUDE_CLI_VERSION_RANGE);
+}
+function validateClaudeCli() {
+  const version = getClaudeCliVersion();
+  if (!version) {
+    return {
+      installed: false,
+      version: null,
+      compatible: false,
+      message: "Claude CLI not found. Install it with: bun install -g @anthropic-ai/claude-code"
+    };
+  }
+  const compatible = isVersionCompatible(version);
+  if (!compatible) {
+    return {
+      installed: true,
+      version,
+      compatible: false,
+      message: `Claude CLI version ${version} is not compatible. Required: ${CLAUDE_CLI_VERSION_RANGE}
+` + `Install a compatible version: bun install -g @anthropic-ai/claude-code@2.0.76`
+    };
+  }
+  return {
+    installed: true,
+    version,
+    compatible: true,
+    message: `Claude CLI ${version} \u2713`
+  };
+}
+
+// src/session/bug-report.ts
+var CATBOX_API_URL = "https://catbox.moe/user/api.php";
+async function uploadImageToCatbox(imageBuffer, filename) {
+  const arrayBuffer = imageBuffer.buffer.slice(imageBuffer.byteOffset, imageBuffer.byteOffset + imageBuffer.byteLength);
+  const formData = new FormData;
+  formData.append("reqtype", "fileupload");
+  formData.append("fileToUpload", new Blob([arrayBuffer]), filename);
+  const response = await fetch(CATBOX_API_URL, {
+    method: "POST",
+    body: formData
+  });
+  if (!response.ok) {
+    throw new Error(`Catbox upload failed: ${response.status} ${response.statusText}`);
+  }
+  const responseText = await response.text();
+  if (responseText.startsWith("https://")) {
+    return responseText.trim();
+  }
+  throw new Error(`Catbox upload failed: ${responseText}`);
+}
+async function uploadImages(files, downloadFile) {
+  const results = [];
+  for (const file of files) {
+    if (!file.mimeType.startsWith("image/")) {
+      results.push({
+        success: false,
+        error: "Not an image file",
+        originalFile: file
+      });
+      continue;
+    }
+    try {
+      const buffer = await downloadFile(file.id);
+      const url = await uploadImageToCatbox(buffer, file.name);
+      results.push({
+        success: true,
+        url,
+        originalFile: file
+      });
+    } catch (err) {
+      results.push({
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        originalFile: file
+      });
+    }
+  }
+  return results;
+}
+var MAX_RECENT_EVENTS = 10;
+var GITHUB_REPO = "anneschuth/claude-threads";
+function trackEvent(session, type, summary) {
+  if (!session.recentEvents) {
+    session.recentEvents = [];
+  }
+  session.recentEvents.push({
+    type,
+    timestamp: Date.now(),
+    summary: summary.substring(0, 100)
+  });
+  if (session.recentEvents.length > MAX_RECENT_EVENTS) {
+    session.recentEvents.shift();
+  }
+}
+function getRecentEvents(session) {
+  return session.recentEvents || [];
+}
+function sanitizePath(path10) {
+  let sanitized = path10.replace(/^\/Users\/[^/]+/, "~").replace(/^\/home\/[^/]+/, "~").replace(/^C:\\Users\\[^\\]+/i, "~");
+  sanitized = sanitized.replace(/\/(tokens?|secrets?|credentials?|\.env)/gi, "/[REDACTED]").replace(/\\(tokens?|secrets?|credentials?|\.env)/gi, "\\[REDACTED]");
+  return sanitized;
+}
+function sanitizeText(text) {
+  return text.replace(/xoxb-[\w-]+/gi, "[SLACK_TOKEN]").replace(/xoxp-[\w-]+/gi, "[SLACK_TOKEN]").replace(/xapp-[\w-]+/gi, "[SLACK_TOKEN]").replace(/xoxa-[\w-]+/gi, "[SLACK_TOKEN]").replace(/ghp_[\w]+/gi, "[GITHUB_TOKEN]").replace(/gho_[\w]+/gi, "[GITHUB_TOKEN]").replace(/github_pat_[\w]+/gi, "[GITHUB_TOKEN]").replace(/sk_live_[\w]+/gi, "[STRIPE_KEY]").replace(/sk_test_[\w]+/gi, "[STRIPE_KEY]").replace(/pk_live_[\w]+/gi, "[STRIPE_KEY]").replace(/pk_test_[\w]+/gi, "[STRIPE_KEY]").replace(/AKIA[\w]{16}/g, "[AWS_KEY]").replace(/['"]?[a-zA-Z_]*(?:api[_-]?key|secret|token|password|credential)['":]?\s*['"]?[\w-]{20,}['"]?/gi, "[REDACTED_KEY]").replace(/\/Users\/[\w.-]+/g, "~").replace(/\/home\/[\w.-]+/g, "~").replace(/C:\\Users\\[\w.-]+/gi, "~");
+}
+async function getCurrentBranch2(workingDir) {
+  try {
+    const output = execSync2("git rev-parse --abbrev-ref HEAD", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+async function collectBugReportContext(session, errorContext) {
+  const branch = await getCurrentBranch2(session.workingDir);
+  let usageStats;
+  if (session.usageStats) {
+    const stats = session.usageStats;
+    const contextPercent = stats.contextWindowSize > 0 ? Math.round(stats.contextTokens / stats.contextWindowSize * 100) : 0;
+    usageStats = {
+      model: stats.modelDisplayName || stats.primaryModel,
+      contextPercent,
+      cost: stats.totalCostUSD.toFixed(2)
+    };
+  }
+  return {
+    version: VERSION,
+    claudeCliVersion: getClaudeCliVersion(),
+    platform: session.platform.displayName,
+    platformType: session.platform.platformType,
+    nodeVersion: process.version,
+    osVersion: `${process.platform} ${process.arch}`,
+    sessionId: session.sessionId,
+    claudeSessionId: session.claudeSessionId,
+    workingDir: sanitizePath(session.workingDir),
+    branch,
+    worktreeBranch: session.worktreeInfo?.branch,
+    usageStats,
+    recentEvents: getRecentEvents(session),
+    errorContext
+  };
+}
+function generateIssueTitle(description) {
+  let title = description.replace(/\s+/g, " ").trim();
+  if (title.length > 80) {
+    title = title.substring(0, 77) + "...";
+  }
+  return title;
+}
+function formatRecentEvents(events) {
+  if (events.length === 0) {
+    return "_No recent events_";
+  }
+  return events.map((e) => {
+    const time = new Date(e.timestamp).toISOString().substring(11, 19);
+    return `[${time}] ${e.type}: ${sanitizeText(e.summary)}`;
+  }).join(`
+`);
+}
+function formatIssueBody(context, userDescription, imageUrls = []) {
+  const sections = [];
+  sections.push(`## Description
+
+${sanitizeText(userDescription)}`);
+  if (imageUrls.length > 0) {
+    const imageSection = imageUrls.map((url, i) => `![Screenshot ${i + 1}](${url})`).join(`
+
+`);
+    sections.push(`## Screenshots
+
+${imageSection}`);
+  }
+  sections.push(`## Environment
+
+| Property | Value |
+|----------|-------|
+| claude-threads | v${context.version} |
+| Claude CLI | ${context.claudeCliVersion || "unknown"} |
+| Platform | ${context.platformType} (${context.platform}) |
+| Node.js | ${context.nodeVersion} |
+| OS | ${context.osVersion} |`);
+  sections.push(`## Session Context
+
+| Property | Value |
+|----------|-------|
+| Session ID | \`${context.claudeSessionId.substring(0, 8)}\` |
+| Working Dir | \`${context.workingDir}\` |
+| Branch | ${context.branch || "N/A"} |
+| Worktree | ${context.worktreeBranch || "N/A"} |`);
+  if (context.usageStats) {
+    sections.push(`## Usage Stats
+
+- **Model:** ${context.usageStats.model}
+- **Context:** ${context.usageStats.contextPercent}%
+- **Cost:** $${context.usageStats.cost}`);
+  }
+  sections.push(`## Recent Events
+
+\`\`\`
+${formatRecentEvents(context.recentEvents)}
+\`\`\``);
+  if (context.errorContext) {
+    sections.push(`## Error Details
+
+**Error message:**
+\`\`\`
+${sanitizeText(context.errorContext.message)}
+\`\`\`
+
+**Occurred at:** ${context.errorContext.timestamp.toISOString()}`);
+  }
+  sections.push(`---
+_Reported via claude-threads bug report feature_`);
+  return sections.join(`
+
+`);
+}
+function escapeShell(str) {
+  return str.replace(/"/g, "\\\"");
+}
+function checkGitHubCli() {
+  try {
+    execSync2("gh --version", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return {
+      installed: false,
+      authenticated: false,
+      error: "GitHub CLI not installed. Install it with: `brew install gh` or see https://cli.github.com"
+    };
+  }
+  try {
+    execSync2("gh auth status", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return {
+      installed: true,
+      authenticated: false,
+      error: "Not logged into GitHub CLI. Run `gh auth login` to authenticate."
+    };
+  }
+  return { installed: true, authenticated: true };
+}
+async function createGitHubIssue(title, body, workingDir) {
+  const ghStatus = checkGitHubCli();
+  if (!ghStatus.installed || !ghStatus.authenticated) {
+    throw new Error(ghStatus.error);
+  }
+  const bodyFile = join4(tmpdir2(), `bug-body-${Date.now()}.md`);
+  try {
+    writeFileSync4(bodyFile, body, "utf-8");
+    const cmd = `gh issue create --repo "${GITHUB_REPO}" --title "${escapeShell(title)}" --body-file "${bodyFile}"`;
+    const result = execSync2(cmd, {
+      cwd: workingDir,
+      encoding: "utf-8",
+      timeout: 30000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } finally {
+    try {
+      unlinkSync2(bodyFile);
+    } catch {}
+  }
+}
+function formatBugPreview(title, description, context, imageUrls, imageErrors, formatter) {
+  const lines = [];
+  lines.push(`${formatter.formatBold("Bug Report Preview")}`);
+  lines.push("");
+  lines.push(`${formatter.formatBold("Title:")} ${title}`);
+  lines.push("");
+  lines.push(formatter.formatBlockquote(description));
+  lines.push("");
+  lines.push(formatter.formatBold("Environment:"));
+  lines.push(formatter.formatListItem(`claude-threads v${context.version}`));
+  lines.push(formatter.formatListItem(`Claude CLI ${context.claudeCliVersion || "unknown"}`));
+  lines.push(formatter.formatListItem(`Platform: ${context.platformType}`));
+  lines.push(formatter.formatListItem(`Branch: ${context.branch || "N/A"}`));
+  if (context.usageStats) {
+    lines.push("");
+    lines.push(formatter.formatBold("Usage:"));
+    lines.push(formatter.formatListItem(`Model: ${context.usageStats.model}`));
+    lines.push(formatter.formatListItem(`Context: ${context.usageStats.contextPercent}%`));
+  }
+  if (context.recentEvents.length > 0) {
+    lines.push("");
+    lines.push(formatter.formatBold(`Recent Events (${context.recentEvents.length}):`));
+    const lastFew = context.recentEvents.slice(-3);
+    for (const event of lastFew) {
+      lines.push(formatter.formatListItem(`${event.type}: ${event.summary.substring(0, 40)}...`));
+    }
+  }
+  if (imageUrls.length > 0 || imageErrors.length > 0) {
+    lines.push("");
+    lines.push(formatter.formatBold("Screenshots:"));
+    if (imageUrls.length > 0) {
+      lines.push(formatter.formatListItem(`\u2705 ${imageUrls.length} image(s) uploaded successfully`));
+    }
+    if (imageErrors.length > 0) {
+      lines.push(formatter.formatListItem(`\u26A0\uFE0F ${imageErrors.length} image(s) failed: ${imageErrors[0]}`));
+    }
+  }
+  lines.push("");
+  lines.push(`React ${formatter.formatCode("\uD83D\uDC4D")} to create GitHub issue or ${formatter.formatCode("\uD83D\uDC4E")} to cancel`);
+  return lines.join(`
+`);
+}
+
 // src/utils/battery.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -50762,58 +51128,6 @@ class KeepAliveManager {
 }
 var keepAlive = new KeepAliveManager;
 
-// src/claude/version-check.ts
-var import_semver3 = __toESM(require_semver2(), 1);
-import { execSync } from "child_process";
-var CLAUDE_CLI_VERSION_RANGE = ">=2.0.74 <2.2.0";
-function getClaudeCliVersion() {
-  const claudePath = process.env.CLAUDE_PATH || "claude";
-  try {
-    const output = execSync(`${claudePath} --version`, {
-      encoding: "utf8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const match = output.match(/^([\d.]+)/);
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-function isVersionCompatible(version) {
-  const semverVersion = import_semver3.coerce(version);
-  if (!semverVersion)
-    return false;
-  return import_semver3.satisfies(semverVersion, CLAUDE_CLI_VERSION_RANGE);
-}
-function validateClaudeCli() {
-  const version = getClaudeCliVersion();
-  if (!version) {
-    return {
-      installed: false,
-      version: null,
-      compatible: false,
-      message: "Claude CLI not found. Install it with: bun install -g @anthropic-ai/claude-code"
-    };
-  }
-  const compatible = isVersionCompatible(version);
-  if (!compatible) {
-    return {
-      installed: true,
-      version,
-      compatible: false,
-      message: `Claude CLI version ${version} is not compatible. Required: ${CLAUDE_CLI_VERSION_RANGE}
-` + `Install a compatible version: bun install -g @anthropic-ai/claude-code@2.0.76`
-    };
-  }
-  return {
-    installed: true,
-    version,
-    compatible: true,
-    message: `Claude CLI ${version} \u2713`
-  };
-}
-
 // src/session/commands.ts
 var log11 = createLogger("commands");
 function sessionLog2(session) {
@@ -51215,6 +51529,71 @@ async function deferUpdate(session, username, updateManager) {
   await postSuccess(session, `\u23F8\uFE0F ${formatter.formatBold("Update deferred")} for 1 hour
 ` + formatter.formatItalic("Use !update now to apply earlier"));
 }
+async function reportBug(session, description, username, ctx, errorContext, attachedFiles) {
+  const formatter = session.platform.getFormatter();
+  if (!description && !errorContext) {
+    await postInfo(session, `Usage: ${formatter.formatCode("!bug <description>")}
+` + `Example: ${formatter.formatCode("!bug Session crashed when uploading large image")}
+
+` + `You can also attach screenshots to the !bug message.
+` + `Or react with \uD83D\uDC1B on any error message to report it.`);
+    return;
+  }
+  const ghStatus = checkGitHubCli();
+  if (!ghStatus.installed || !ghStatus.authenticated) {
+    await postError(session, ghStatus.error || "GitHub CLI not configured");
+    return;
+  }
+  const bugDescription = description || (errorContext ? `Error: ${errorContext.message.substring(0, 200)}` : "Unknown error");
+  const context = await collectBugReportContext(session, errorContext);
+  let imageUrls = [];
+  let imageErrors = [];
+  const downloadFile = session.platform.downloadFile;
+  if (attachedFiles && attachedFiles.length > 0 && downloadFile) {
+    await postInfo(session, `\uD83D\uDCE4 Uploading ${attachedFiles.length} image(s)...`);
+    const uploadResults = await uploadImages(attachedFiles, (fileId) => downloadFile(fileId));
+    imageUrls = uploadResults.filter((r) => r.success && typeof r.url === "string").map((r) => r.url);
+    imageErrors = uploadResults.filter((r) => !r.success).map((r) => `${r.originalFile.name}: ${r.error}`);
+  }
+  const title = generateIssueTitle(bugDescription);
+  const body = formatIssueBody(context, bugDescription, imageUrls);
+  const preview = formatBugPreview(title, bugDescription, context, imageUrls, imageErrors, formatter);
+  const previewMessage = `\uD83D\uDC1B ${preview}`;
+  const post = await session.platform.createInteractivePost(previewMessage, [APPROVAL_EMOJIS[0], DENIAL_EMOJIS[0]], session.threadId);
+  session.pendingBugReport = {
+    postId: post.id,
+    title,
+    body,
+    userDescription: bugDescription,
+    imageUrls,
+    imageErrors,
+    errorContext
+  };
+  ctx.ops.registerPost(post.id, session.threadId);
+  updateLastMessage(session, post);
+  sessionLog2(session).info(`\uD83D\uDC1B Bug report preview created by @${username}: ${title}`);
+}
+async function handleBugReportApproval(session, isApproved, username) {
+  const pending = session.pendingBugReport;
+  if (!pending)
+    return;
+  const formatter = session.platform.getFormatter();
+  if (isApproved) {
+    try {
+      const issueUrl = await createGitHubIssue(pending.title, pending.body, session.workingDir);
+      await withErrorHandling(() => session.platform.updatePost(pending.postId, `\u2705 ${formatter.formatBold("Bug report submitted")}: ${issueUrl}`), { action: "Update bug report post", session });
+      sessionLog2(session).info(`\uD83D\uDC1B Bug report created by @${username}: ${issueUrl}`);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      await withErrorHandling(() => session.platform.updatePost(pending.postId, `\u274C ${formatter.formatBold("Failed to create bug report")}: ${errorMessage}`), { action: "Update bug report post", session });
+      sessionLog2(session).error(`Failed to create bug report: ${errorMessage}`);
+    }
+  } else {
+    await withErrorHandling(() => session.platform.updatePost(pending.postId, `\uD83D\uDEAB ${formatter.formatBold("Bug report cancelled")} by ${formatter.formatUserMention(username)}`), { action: "Update bug report post", session });
+    sessionLog2(session).info(`\uD83D\uDC1B Bug report cancelled by @${username}`);
+  }
+  session.pendingBugReport = undefined;
+}
 
 // src/session/worktree.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -51635,7 +52014,8 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
 // src/commands/parser.ts
 var CLAUDE_ALLOWED_COMMANDS = new Set([
   "cd",
-  "worktree list"
+  "worktree list",
+  "bug"
 ]);
 var COMMAND_PATTERNS = [
   ["stop", /^!(?:stop|cancel)\s*$/i],
@@ -51652,7 +52032,8 @@ var COMMAND_PATTERNS = [
   ["context", /^!context\s*$/i],
   ["cost", /^!cost\s*$/i],
   ["compact", /^!compact\s*$/i],
-  ["kill", /^!kill\s*$/i]
+  ["kill", /^!kill\s*$/i],
+  ["bug", /^!bug(?:\s+(.+))?$/i]
 ];
 function parseCommand(text) {
   for (const [command, pattern] of COMMAND_PATTERNS) {
@@ -51684,6 +52065,14 @@ function parseClaudeCommand(text) {
       match: worktreeListMatch[0].trimEnd()
     };
   }
+  const bugMatch = text.match(/^!bug\s+(.+)$/m);
+  if (bugMatch && CLAUDE_ALLOWED_COMMANDS.has("bug")) {
+    return {
+      command: "bug",
+      args: bugMatch[1].trim(),
+      match: bugMatch[0].trimEnd()
+    };
+  }
   return null;
 }
 function isClaudeAllowedCommand(command) {
@@ -51783,6 +52172,9 @@ ${plainMessage}
       }
       break;
     }
+    case "bug":
+      await reportBug(session, args, session.startedBy, ctx);
+      break;
   }
 }
 function extractAndUpdatePullRequest(text, session, ctx) {
@@ -51902,6 +52294,7 @@ function formatEvent(session, e, ctx) {
       if (tool.id) {
         session.activeToolStarts.set(tool.id, Date.now());
       }
+      trackEvent(session, "tool_use", tool.name);
       const worktreeInfo = session.worktreeInfo ? { path: session.worktreeInfo.worktreePath, branch: session.worktreeInfo.branch } : undefined;
       return formatToolUse(tool.name, tool.input || {}, session.platform.getFormatter(), { detailed: true, worktreeInfo }) || null;
     }
@@ -51918,8 +52311,10 @@ function formatEvent(session, e, ctx) {
           session.activeToolStarts.delete(result.tool_use_id);
         }
       }
-      if (result.is_error)
+      if (result.is_error) {
+        trackEvent(session, "tool_error", "Tool execution failed");
         return `  \u21B3 \u274C Error${elapsed}`;
+      }
       if (elapsed)
         return `  \u21B3 \u2713${elapsed}`;
       return null;
@@ -51935,8 +52330,10 @@ function formatEvent(session, e, ctx) {
       return null;
     }
     case "system": {
-      if (e.subtype === "error")
+      if (e.subtype === "error") {
+        trackEvent(session, "system_error", String(e.error).substring(0, 80));
         return `\u274C ${e.error}`;
+      }
       return null;
     }
     case "user": {
@@ -51978,6 +52375,28 @@ async function handleExitPlanMode(session, toolUseId, ctx) {
   session.pendingApproval = { postId: post.id, type: "plan", toolUseId };
   ctx.ops.stopTyping(session);
 }
+async function cleanupOrphanedTaskPosts(session, currentTaskPostId) {
+  try {
+    const history = await session.platform.getThreadHistory(session.threadId, { limit: 50 });
+    const taskPostPattern = /^(?:(?:---|___|\*\*\*|\u2014+)\s*\n)?\uD83D\uDCCB/;
+    let cleanedCount = 0;
+    for (const msg of history) {
+      if (msg.id === currentTaskPostId)
+        continue;
+      if (!taskPostPattern.test(msg.message))
+        continue;
+      sessionLog4(session).info(`Cleaning up orphaned task post ${msg.id.substring(0, 8)}`);
+      await session.platform.unpinPost(msg.id).catch(() => {});
+      await session.platform.deletePost(msg.id).catch(() => {});
+      cleanedCount++;
+    }
+    if (cleanedCount > 0) {
+      sessionLog4(session).info(`Cleaned up ${cleanedCount} orphaned task post(s)`);
+    }
+  } catch (err) {
+    sessionLog4(session).debug(`Task cleanup failed: ${err}`);
+  }
+}
 async function handleTodoWrite(session, input, ctx) {
   const releaseLock = await acquireTaskListLock(session);
   try {
@@ -52066,14 +52485,20 @@ async function handleTodoWriteWithLock(session, input, ctx) {
   const displayMessage = session.tasksMinimized ? minimizedMessage : fullMessage;
   const existingTasksPostId = session.tasksPostId;
   if (existingTasksPostId) {
-    await withErrorHandling(() => session.platform.updatePost(existingTasksPostId, displayMessage), { action: "Update tasks", session });
-  } else {
+    const updated = await withErrorHandling(() => session.platform.updatePost(existingTasksPostId, displayMessage), { action: "Update tasks", session });
+    if (updated === undefined) {
+      sessionLog4(session).warn(`Task post ${existingTasksPostId.substring(0, 8)} update failed, will create new one`);
+      session.tasksPostId = null;
+    }
+  }
+  if (!session.tasksPostId) {
     const post = await withErrorHandling(() => session.platform.createInteractivePost(displayMessage, [TASK_TOGGLE_EMOJIS[0]], session.threadId), { action: "Create tasks post", session });
     if (post) {
       session.tasksPostId = post.id;
       ctx.ops.registerPost(post.id, session.threadId);
       updateLastMessage(session, post);
       await session.platform.pinPost(post.id).catch(() => {});
+      await cleanupOrphanedTaskPosts(session, post.id);
     }
   }
   ctx.ops.updateStickyMessage().catch(() => {});
@@ -52472,6 +52897,36 @@ async function handleUpdateReaction(session, postId, emojiName, username, ctx, u
   }
   return true;
 }
+async function handleBugReportReaction(session, postId, emojiName, username, ctx) {
+  if (!isBugReportEmoji(emojiName)) {
+    return false;
+  }
+  if (!session.lastError || session.lastError.postId !== postId) {
+    return false;
+  }
+  if (session.startedBy !== username && !session.platform.isUserAllowed(username) && !session.sessionAllowedUsers.has(username)) {
+    return false;
+  }
+  sessionLog5(session).info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
+  await reportBug(session, undefined, username, ctx, session.lastError);
+  return true;
+}
+async function handleBugApprovalReaction(session, postId, emojiName, username, _ctx) {
+  const pending = session.pendingBugReport;
+  if (!pending || pending.postId !== postId) {
+    return false;
+  }
+  if (session.startedBy !== username && !session.platform.isUserAllowed(username) && !session.sessionAllowedUsers.has(username)) {
+    return false;
+  }
+  const isApprove = isApprovalEmoji(emojiName);
+  const isDeny = isDenialEmoji(emojiName);
+  if (!isApprove && !isDeny) {
+    return false;
+  }
+  await handleBugReportApproval(session, isApprove, username);
+  return true;
+}
 
 // src/session/lifecycle.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -52686,7 +53141,8 @@ ${CHAT_PLATFORM_PROMPT}`;
     firstPrompt: options.prompt,
     messageCount: 0,
     isProcessing: true,
-    statusBarTimer: null
+    statusBarTimer: null,
+    recentEvents: []
   };
   mutableSessions(ctx).set(sessionId, session);
   ctx.ops.registerPost(post.id, actualThreadId);
@@ -52843,7 +53299,8 @@ ${CHAT_PLATFORM_PROMPT}`;
     messageCount: state.messageCount ?? 0,
     isProcessing: false,
     lifecyclePostId: state.lifecyclePostId,
-    statusBarTimer: null
+    statusBarTimer: null,
+    recentEvents: []
   };
   mutableSessions(ctx).set(sessionId, session);
   if (session.worktreeInfo) {
@@ -54066,6 +54523,16 @@ class SessionManager extends EventEmitter4 {
       await handleTaskToggleReaction(session, action, this.getContext());
       return;
     }
+    if (action === "added" && session.lastError?.postId === postId) {
+      const handled = await handleBugReportReaction(session, postId, emojiName, username, this.getContext());
+      if (handled)
+        return;
+    }
+    if (action === "added" && session.pendingBugReport?.postId === postId) {
+      const handled = await handleBugApprovalReaction(session, postId, emojiName, username, this.getContext());
+      if (handled)
+        return;
+    }
   }
   getContextPromptHandler() {
     return {
@@ -54315,7 +54782,7 @@ class SessionManager extends EventEmitter4 {
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const worktreePath = join4(worktreesDir, entry.name);
+        const worktreePath = join5(worktreesDir, entry.name);
         if (activeWorktrees.has(worktreePath)) {
           log18.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
           continue;
@@ -54493,6 +54960,12 @@ class SessionManager extends EventEmitter4 {
       return;
     await enableInteractivePermissions(session, username, this.getContext());
   }
+  async reportBug(threadId, description, username, files) {
+    const session = this.findSessionByThreadId(threadId);
+    if (!session)
+      return;
+    await reportBug(session, description, username, this.getContext(), undefined, files);
+  }
   async showUpdateStatus(threadId, _username) {
     const session = this.findSessionByThreadId(threadId);
     if (!session)
@@ -65233,7 +65706,8 @@ async function handleMessage(client, session, post, user, options) {
               [code("!update defer"), "Defer pending update for 1 hour"],
               [code("!escape"), "Interrupt current task (session stays active)"],
               [code("!stop"), "Stop this session"],
-              [code("!kill"), "Emergency shutdown (kills ALL sessions, exits bot)"]
+              [code("!kill"), "Emergency shutdown (kills ALL sessions, exits bot)"],
+              [code("!bug <description>"), "Report a bug (creates GitHub issue)"]
             ]);
             await client.createPost(`${formatter.formatBold("Commands:")}
 
@@ -65328,6 +65802,12 @@ Release notes not available. See ${formatter.formatLink("GitHub releases", "http
               await session.sendFollowUp(threadRoot, claudeCommand);
             }
             return;
+          case "bug":
+            if (isAllowed) {
+              const files3 = post.metadata?.files;
+              await session.reportBug(threadRoot, parsed.args, username, files3);
+            }
+            return;
           case "kill":
             return;
         }
@@ -65799,7 +66279,7 @@ class UpdateScheduler extends EventEmitter8 {
 
 // src/auto-update/installer.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname6, resolve as resolve6 } from "path";
 import { homedir as homedir4 } from "os";
 var log21 = createLogger("installer");
@@ -65822,7 +66302,7 @@ function saveUpdateState(state) {
     if (!existsSync11(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
-    writeFileSync4(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync5(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
     log21.debug("Update state saved");
   } catch (err) {
     log21.warn(`Failed to save update state: ${err}`);
@@ -65831,7 +66311,7 @@ function saveUpdateState(state) {
 function clearUpdateState() {
   try {
     if (existsSync11(STATE_PATH)) {
-      writeFileSync4(STATE_PATH, "{}", "utf-8");
+      writeFileSync5(STATE_PATH, "{}", "utf-8");
     }
   } catch (err) {
     log21.warn(`Failed to clear update state: ${err}`);

package/dist/mcp/permission-server.js

@@ -33831,9 +33831,11 @@ ${code}
 `);
   }
   formatMarkdown(content) {
-    return content.replace(/\n{3,}/g, `
+    let processed = content.replace(/(?<=\n)```(?=\S)(?![a-zA-Z]*\n)/g, "```\n");
+    processed = processed.replace(/\n{3,}/g, `
 
 `);
+    return processed;
   }
 }
 
@@ -34104,6 +34106,7 @@ function convertMarkdownToSlack(content) {
   for (let i = 0;i < codeBlocks.length; i++) {
     preserved = preserved.replace(`${CODE_BLOCK_PLACEHOLDER}${i}\x00`, codeBlocks[i]);
   }
+  preserved = preserved.replace(/(?<=\n)```(?=\S)(?![a-zA-Z]*\n)/g, "```\n");
   return preserved;
 }
 function convertMarkdownTablesToSlack(content) {

package/package.json

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