claude-threads 0.29.0 → 0.31.0

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.31.0] - 2026-01-03
+
+### Added
+- **Session history retention** - Sessions are now soft-deleted instead of permanently removed when they complete. Session history is kept for display in the sticky message (up to 5 recent sessions). Old history is permanently cleaned up after 3 days.
+- **Git branch in session header** - Display the current git branch in the session header table when working in a git repository, providing visibility into which branch the session is operating on.
+
+### Fixed
+- **Accurate context usage via status line** - Uses Claude Code's status line feature to get accurate context window usage percentage instead of cumulative billing tokens. Adds a status line writer script that receives accurate per-request token data.
+
+## [0.30.0] - 2026-01-03
+
+### Added
+- **Pull request link detection** - When a session is working in a git worktree with an associated PR, the session header and sticky message now display a clickable link to the PR. Automatically detects PRs from GitHub URLs in branch names or upstream tracking.
+- **User existence validation for invite/kick** - The `!invite` and `!kick` commands now validate that the user exists on the platform before attempting the action, providing helpful error messages for non-existent users.
+
+### Fixed
+- **Accurate context window usage** - Now uses per-request usage data from Claude's result events instead of cumulative billing tokens, providing accurate context window percentage display.
+- **Cancelled sessions no longer resume** - Fixed bug where cancelled sessions (killed by user) would incorrectly resume on bot restart by using the correct composite session key for unpersisting.
+
 ## [0.29.0] - 2026-01-03
 
 ### Changed

package/dist/index.js

@@ -13394,6 +13394,15 @@ class MattermostClient extends EventEmitter {
       return null;
     }
   }
+  async getUserByUsername(username) {
+    try {
+      const user = await this.api("GET", `/users/username/${username}`);
+      this.userCache.set(user.id, user);
+      return this.normalizePlatformUser(user);
+    } catch {
+      return null;
+    }
+  }
   async createPost(message, threadId) {
     const request = {
       channel_id: this.channelId,
@@ -13713,10 +13722,12 @@ class SessionStore {
         return sessions;
       }
       for (const session of Object.values(data.sessions)) {
+        if (session.cleanedAt)
+          continue;
         const sessionId = `${session.platformId}:${session.threadId}`;
         sessions.set(sessionId, session);
       }
-      log3.debug(`Loaded ${sessions.size} session(s)`);
+      log3.debug(`Loaded ${sessions.size} active session(s)`);
     } catch (err) {
       log3.error(`Failed to load sessions: ${err}`);
     }
@@ -13738,23 +13749,67 @@ class SessionStore {
       log3.debug(`Removed session ${shortId}...`);
     }
   }
+  softDelete(sessionId) {
+    const data = this.loadRaw();
+    if (data.sessions[sessionId]) {
+      data.sessions[sessionId].cleanedAt = new Date().toISOString();
+      this.writeAtomic(data);
+      const shortId = sessionId.substring(0, 20);
+      log3.debug(`Soft-deleted session ${shortId}...`);
+    }
+  }
   cleanStale(maxAgeMs) {
     const data = this.loadRaw();
     const now = Date.now();
     const staleIds = [];
     for (const [sessionId, session] of Object.entries(data.sessions)) {
+      if (session.cleanedAt)
+        continue;
       const lastActivity = new Date(session.lastActivityAt).getTime();
       if (now - lastActivity > maxAgeMs) {
         staleIds.push(sessionId);
-        delete data.sessions[sessionId];
+        session.cleanedAt = new Date().toISOString();
       }
     }
     if (staleIds.length > 0) {
       this.writeAtomic(data);
-      log3.debug(`Cleaned ${staleIds.length} stale session(s)`);
+      log3.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
     }
     return staleIds;
   }
+  cleanHistory(historyRetentionMs = 3 * 24 * 60 * 60 * 1000) {
+    const data = this.loadRaw();
+    const now = Date.now();
+    let removedCount = 0;
+    for (const [sessionId, session] of Object.entries(data.sessions)) {
+      if (!session.cleanedAt)
+        continue;
+      const cleanedTime = new Date(session.cleanedAt).getTime();
+      if (now - cleanedTime > historyRetentionMs) {
+        delete data.sessions[sessionId];
+        removedCount++;
+      }
+    }
+    if (removedCount > 0) {
+      this.writeAtomic(data);
+      log3.debug(`Permanently removed ${removedCount} old session(s) from history`);
+    }
+    return removedCount;
+  }
+  getHistory(platformId) {
+    const data = this.loadRaw();
+    const historySessions = [];
+    for (const session of Object.values(data.sessions)) {
+      if (session.platformId === platformId && session.cleanedAt) {
+        historySessions.push(session);
+      }
+    }
+    return historySessions.sort((a, b) => {
+      const aTime = new Date(a.cleanedAt).getTime();
+      const bTime = new Date(b.cleanedAt).getTime();
+      return bTime - aTime;
+    });
+  }
   clear() {
     const data = this.loadRaw();
     this.writeAtomic({ version: STORE_VERSION, sessions: {}, stickyPostIds: data.stickyPostIds });
@@ -15014,6 +15069,65 @@ async function logAndNotify(error2, context) {
   await handleError(error2, { ...context, notifyUser: true }, "recoverable");
 }
 
+// src/utils/pr-detector.ts
+var PR_PATTERNS = [
+  {
+    platform: "github",
+    pattern: /https?:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/gi
+  },
+  {
+    platform: "gitlab",
+    pattern: /https?:\/\/[^/]*gitlab[^/]*\/([^/]+(?:\/[^/]+)+)\/-\/merge_requests\/(\d+)/gi
+  },
+  {
+    platform: "bitbucket",
+    pattern: /https?:\/\/bitbucket\.org\/([^/]+\/[^/]+)\/pull-requests\/(\d+)/gi
+  },
+  {
+    platform: "azure",
+    pattern: /https?:\/\/dev\.azure\.com\/([^/]+\/[^/]+\/_git\/[^/]+)\/pullrequest\/(\d+)/gi
+  },
+  {
+    platform: "azure",
+    pattern: /https?:\/\/[^/]+\.visualstudio\.com\/([^/]+\/_git\/[^/]+)\/pullrequest\/(\d+)/gi
+  }
+];
+function detectPullRequests(text) {
+  const results = [];
+  const seenUrls = new Set;
+  for (const { platform, pattern } of PR_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const url = match[0];
+      if (seenUrls.has(url))
+        continue;
+      seenUrls.add(url);
+      results.push({
+        url,
+        platform,
+        repo: match[1],
+        number: match[2]
+      });
+    }
+  }
+  return results;
+}
+function extractPullRequestUrl(text) {
+  const prs = detectPullRequests(text);
+  return prs.length > 0 ? prs[0].url : null;
+}
+function formatPullRequestLink(url) {
+  const prs = detectPullRequests(url);
+  if (prs.length === 0)
+    return url;
+  const pr = prs[0];
+  if (pr.platform === "gitlab") {
+    return `[\uD83D\uDD17 MR !${pr.number}](${url})`;
+  }
+  return `[\uD83D\uDD17 PR #${pr.number}](${url})`;
+}
+
 // src/session/events.ts
 var log6 = createLogger("events");
 function extractAndUpdateMetadata(text, session, config, sessionField, ctx) {
@@ -15044,6 +15158,18 @@ var DESCRIPTION_CONFIG = {
   maxLength: 100,
   placeholder: "<brief description>"
 };
+function extractAndUpdatePullRequest(text, session, ctx) {
+  if (session.pullRequestUrl)
+    return;
+  const prUrl = extractPullRequestUrl(text);
+  if (prUrl) {
+    session.pullRequestUrl = prUrl;
+    log6.info(`\uD83D\uDD17 Detected PR URL: ${prUrl}`);
+    ctx.ops.persistSession(session);
+    ctx.ops.updateStickyMessage().catch(() => {});
+    ctx.ops.updateSessionHeader(session).catch(() => {});
+  }
+}
 function handleEvent(session, event, ctx) {
   session.lastActivityAt = new Date;
   session.timeoutWarningPosted = false;
@@ -15100,6 +15226,7 @@ function formatEvent(session, e, ctx) {
           let text = block.text.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
           text = extractAndUpdateMetadata(text, session, TITLE_CONFIG, "sessionTitle", ctx);
           text = extractAndUpdateMetadata(text, session, DESCRIPTION_CONFIG, "sessionDescription", ctx);
+          extractAndUpdatePullRequest(text, session, ctx);
           if (text)
             parts.push(text);
         } else if (block.type === "tool_use" && block.name) {
@@ -15380,7 +15507,6 @@ function updateUsageStats(session, event, ctx) {
   let primaryModel = "";
   let highestCost = 0;
   let contextWindowSize = 200000;
-  let contextTokens = 0;
   const modelUsage = {};
   let totalTokensUsed = 0;
   for (const [modelId, usage] of Object.entries(result.modelUsage)) {
@@ -15397,9 +15523,15 @@ function updateUsageStats(session, event, ctx) {
       highestCost = usage.costUSD;
       primaryModel = modelId;
       contextWindowSize = usage.contextWindow;
-      contextTokens = usage.inputTokens + usage.cacheReadInputTokens;
     }
   }
+  let contextTokens = 0;
+  if (result.usage) {
+    contextTokens = result.usage.input_tokens + result.usage.cache_creation_input_tokens + result.usage.cache_read_input_tokens;
+  } else if (primaryModel && result.modelUsage[primaryModel]) {
+    const primary = result.modelUsage[primaryModel];
+    contextTokens = primary.inputTokens + primary.cacheReadInputTokens;
+  }
   const usageStats = {
     primaryModel,
     modelDisplayName: getModelDisplayName(primaryModel),
@@ -15411,17 +15543,41 @@ function updateUsageStats(session, event, ctx) {
     lastUpdated: new Date
   };
   session.usageStats = usageStats;
-  log6.debug(`Updated usage stats: ${usageStats.modelDisplayName}, ` + `${usageStats.totalTokensUsed}/${usageStats.contextWindowSize} tokens, ` + `$${usageStats.totalCostUSD.toFixed(4)}`);
+  const contextPct = contextWindowSize > 0 ? Math.round(contextTokens / contextWindowSize * 100) : 0;
+  log6.debug(`Updated usage stats: ${usageStats.modelDisplayName}, ` + `context ${contextTokens}/${contextWindowSize} (${contextPct}%), ` + `$${usageStats.totalCostUSD.toFixed(4)}`);
   if (!session.statusBarTimer) {
     const STATUS_BAR_UPDATE_INTERVAL = 30000;
     session.statusBarTimer = setInterval(() => {
       if (session.claude.isRunning()) {
+        updateUsageFromStatusLine(session);
         ctx.ops.updateSessionHeader(session).catch(() => {});
       }
     }, STATUS_BAR_UPDATE_INTERVAL);
   }
   ctx.ops.updateSessionHeader(session).catch(() => {});
 }
+function updateUsageFromStatusLine(session) {
+  const statusData = session.claude.getStatusData();
+  if (!statusData || !statusData.current_usage)
+    return;
+  if (!session.usageStats)
+    return;
+  const contextTokens = statusData.current_usage.input_tokens + statusData.current_usage.cache_creation_input_tokens + statusData.current_usage.cache_read_input_tokens;
+  if (statusData.timestamp > session.usageStats.lastUpdated.getTime()) {
+    session.usageStats.contextTokens = contextTokens;
+    session.usageStats.contextWindowSize = statusData.context_window_size;
+    session.usageStats.lastUpdated = new Date(statusData.timestamp);
+    if (statusData.model) {
+      session.usageStats.primaryModel = statusData.model.id;
+      session.usageStats.modelDisplayName = statusData.model.display_name;
+    }
+    if (statusData.cost) {
+      session.usageStats.totalCostUSD = statusData.cost.total_cost_usd;
+    }
+    const contextPct = session.usageStats.contextWindowSize > 0 ? Math.round(contextTokens / session.usageStats.contextWindowSize * 100) : 0;
+    log6.debug(`Updated from status line: context ${contextTokens}/${session.usageStats.contextWindowSize} (${contextPct}%)`);
+  }
+}
 
 // src/session/reactions.ts
 var log7 = createLogger("reactions");
@@ -15573,6 +15729,7 @@ import { spawn } from "child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
+import { existsSync as existsSync4, readFileSync as readFileSync4, watchFile, unwatchFile, unlinkSync } from "fs";
 var log8 = createLogger("claude");
 
 class ClaudeCli extends EventEmitter2 {
@@ -15580,10 +15737,48 @@ class ClaudeCli extends EventEmitter2 {
   options;
   buffer = "";
   debug = process.env.DEBUG === "1" || process.argv.includes("--debug");
+  statusFilePath = null;
+  lastStatusData = null;
   constructor(options) {
     super();
     this.options = options;
   }
+  getStatusFilePath() {
+    return this.statusFilePath;
+  }
+  getStatusData() {
+    if (!this.statusFilePath)
+      return null;
+    try {
+      if (existsSync4(this.statusFilePath)) {
+        const data = readFileSync4(this.statusFilePath, "utf8");
+        this.lastStatusData = JSON.parse(data);
+      }
+    } catch {}
+    return this.lastStatusData;
+  }
+  startStatusWatch() {
+    if (!this.statusFilePath)
+      return;
+    const checkStatus = () => {
+      const data = this.getStatusData();
+      if (data && data.timestamp !== this.lastStatusData?.timestamp) {
+        this.lastStatusData = data;
+        this.emit("status", data);
+      }
+    };
+    watchFile(this.statusFilePath, { interval: 1000 }, checkStatus);
+  }
+  stopStatusWatch() {
+    if (this.statusFilePath) {
+      unwatchFile(this.statusFilePath);
+      try {
+        if (existsSync4(this.statusFilePath)) {
+          unlinkSync(this.statusFilePath);
+        }
+      } catch {}
+    }
+  }
   start() {
     if (this.process)
       throw new Error("Already running");
@@ -15638,6 +15833,18 @@ class ClaudeCli extends EventEmitter2 {
     if (this.options.appendSystemPrompt) {
       args.push("--append-system-prompt", this.options.appendSystemPrompt);
     }
+    if (this.options.sessionId) {
+      this.statusFilePath = `/tmp/claude-threads-status-${this.options.sessionId}.json`;
+      const statusLineWriterPath = this.getStatusLineWriterPath();
+      const statusLineSettings = {
+        statusLine: {
+          type: "command",
+          command: `node ${statusLineWriterPath} ${this.options.sessionId}`,
+          padding: 0
+        }
+      };
+      args.push("--settings", JSON.stringify(statusLineSettings));
+    }
     log8.debug(`Starting: ${claudePath} ${args.slice(0, 5).join(" ")}...`);
     this.process = spawn(claudePath, args, {
       cwd: this.options.workingDir,
@@ -15713,6 +15920,7 @@ class ClaudeCli extends EventEmitter2 {
     return this.process !== null;
   }
   kill() {
+    this.stopStatusWatch();
     this.process?.kill("SIGTERM");
     this.process = null;
   }
@@ -15727,12 +15935,17 @@ class ClaudeCli extends EventEmitter2 {
     const __dirname2 = dirname2(__filename2);
     return resolve2(__dirname2, "..", "mcp", "permission-server.js");
   }
+  getStatusLineWriterPath() {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = dirname2(__filename2);
+    return resolve2(__dirname2, "..", "statusline", "writer.js");
+  }
 }
 
 // src/session/commands.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { resolve as resolve5 } from "path";
-import { existsSync as existsSync6, statSync } from "fs";
+import { existsSync as existsSync7, statSync } from "fs";
 
 // node_modules/update-notifier/update-notifier.js
 import process10 from "process";
@@ -19023,7 +19236,7 @@ function updateNotifier(options) {
 var import_semver2 = __toESM(require_semver2(), 1);
 
 // src/version.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
 import { dirname as dirname3, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname4 = dirname3(fileURLToPath4(import.meta.url));
@@ -19034,9 +19247,9 @@ function loadPackageJson() {
     resolve3(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
-    if (existsSync4(candidate)) {
+    if (existsSync5(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync4(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(candidate, "utf-8"));
         if (pkg.name === "claude-threads") {
           return { version: pkg.version, name: pkg.name };
         }
@@ -19079,7 +19292,7 @@ function getUpdateInfo() {
 }
 
 // src/changelog.ts
-import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
 import { dirname as dirname4, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __dirname5 = dirname4(fileURLToPath5(import.meta.url));
@@ -19090,7 +19303,7 @@ function getReleaseNotes(version) {
   ];
   let changelogPath = null;
   for (const p of possiblePaths) {
-    if (existsSync5(p)) {
+    if (existsSync6(p)) {
       changelogPath = p;
       break;
     }
@@ -19099,7 +19312,7 @@ function getReleaseNotes(version) {
     return null;
   }
   try {
-    const content = readFileSync5(changelogPath, "utf-8");
+    const content = readFileSync6(changelogPath, "utf-8");
     return parseChangelog(content, version);
   } catch {
     return null;
@@ -19517,6 +19730,170 @@ async function postUser(session, message) {
   return session.platform.createPost(`\uD83D\uDC64 ${message}`, session.threadId);
 }
 
+// src/git/worktree.ts
+import { spawn as spawn4 } from "child_process";
+import { randomUUID } from "crypto";
+import * as path9 from "path";
+import * as fs5 from "fs/promises";
+async function execGit(args, cwd) {
+  return new Promise((resolve5, reject) => {
+    const proc = spawn4("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) {
+        resolve5(stdout.trim());
+      } else {
+        reject(new Error(`git ${args.join(" ")} failed: ${stderr || stdout}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function isGitRepository(dir) {
+  try {
+    await execGit(["rev-parse", "--git-dir"], dir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getRepositoryRoot(dir) {
+  return execGit(["rev-parse", "--show-toplevel"], dir);
+}
+async function getCurrentBranch(dir) {
+  try {
+    const branch = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], dir);
+    return branch === "HEAD" ? null : branch;
+  } catch {
+    return null;
+  }
+}
+async function hasUncommittedChanges(dir) {
+  try {
+    const staged = await execGit(["diff", "--cached", "--quiet"], dir).catch(() => "changes");
+    if (staged === "changes")
+      return true;
+    const unstaged = await execGit(["diff", "--quiet"], dir).catch(() => "changes");
+    if (unstaged === "changes")
+      return true;
+    const untracked = await execGit(["ls-files", "--others", "--exclude-standard"], dir);
+    return untracked.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function listWorktrees(repoRoot) {
+  const output = await execGit(["worktree", "list", "--porcelain"], repoRoot);
+  const worktrees = [];
+  if (!output)
+    return worktrees;
+  const blocks = output.split(`
+
+`).filter(Boolean);
+  for (const block of blocks) {
+    const lines = block.split(`
+`);
+    const worktree = {};
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        worktree.path = line.slice(9);
+      } else if (line.startsWith("HEAD ")) {
+        worktree.commit = line.slice(5);
+      } else if (line.startsWith("branch ")) {
+        worktree.branch = line.slice(7).replace("refs/heads/", "");
+      } else if (line === "bare") {
+        worktree.isBare = true;
+      } else if (line === "detached") {
+        worktree.branch = "(detached)";
+      }
+    }
+    if (worktree.path) {
+      worktrees.push({
+        path: worktree.path,
+        branch: worktree.branch || "(unknown)",
+        commit: worktree.commit || "",
+        isMain: worktrees.length === 0,
+        isBare: worktree.isBare || false
+      });
+    }
+  }
+  return worktrees;
+}
+async function branchExists(repoRoot, branch) {
+  try {
+    await execGit(["rev-parse", "--verify", `refs/heads/${branch}`], repoRoot);
+    return true;
+  } catch {
+    try {
+      await execGit(["rev-parse", "--verify", `refs/remotes/origin/${branch}`], repoRoot);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function getWorktreeDir(repoRoot, branch) {
+  const repoName = path9.basename(repoRoot);
+  const parentDir = path9.dirname(repoRoot);
+  const worktreesDir = path9.join(parentDir, `${repoName}-worktrees`);
+  const sanitizedBranch = branch.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
+  const shortUuid = randomUUID().slice(0, 8);
+  return path9.join(worktreesDir, `${sanitizedBranch}-${shortUuid}`);
+}
+async function createWorktree(repoRoot, branch, targetDir) {
+  const parentDir = path9.dirname(targetDir);
+  await fs5.mkdir(parentDir, { recursive: true });
+  const exists = await branchExists(repoRoot, branch);
+  if (exists) {
+    await execGit(["worktree", "add", targetDir, branch], repoRoot);
+  } else {
+    await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
+  }
+  return targetDir;
+}
+async function removeWorktree(repoRoot, worktreePath) {
+  try {
+    await execGit(["worktree", "remove", worktreePath], repoRoot);
+  } catch {
+    await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
+  }
+  await execGit(["worktree", "prune"], repoRoot);
+}
+async function findWorktreeByBranch(repoRoot, branch) {
+  const worktrees = await listWorktrees(repoRoot);
+  return worktrees.find((wt) => wt.branch === branch) || null;
+}
+function isValidBranchName(name) {
+  if (!name || name.length === 0)
+    return false;
+  if (name.startsWith("/") || name.endsWith("/"))
+    return false;
+  if (name.includes(".."))
+    return false;
+  if (/[\s~^:?*[\]\\]/.test(name))
+    return false;
+  if (name.startsWith("-"))
+    return false;
+  if (name.endsWith(".lock"))
+    return false;
+  if (name.includes("@{"))
+    return false;
+  if (name === "@")
+    return false;
+  if (/\.\./.test(name))
+    return false;
+  return true;
+}
+
 // src/session/commands.ts
 var log9 = createLogger("commands");
 async function restartClaudeSession(session, cliOptions, ctx, actionName) {
@@ -19588,7 +19965,7 @@ async function changeDirectory(session, newDir, username, ctx) {
   }
   const expandedDir = newDir.startsWith("~") ? newDir.replace("~", process.env.HOME || "") : newDir;
   const absoluteDir = resolve5(expandedDir);
-  if (!existsSync6(absoluteDir)) {
+  if (!existsSync7(absoluteDir)) {
     await postError(session, `Directory does not exist: \`${newDir}\``);
     return;
   }
@@ -19600,7 +19977,7 @@ async function changeDirectory(session, newDir, username, ctx) {
   const shortDir = absoluteDir.replace(process.env.HOME || "", "~");
   log9.info(`\uD83D\uDCC2 Session (${shortId}\u2026) changing directory to ${shortDir}`);
   session.workingDir = absoluteDir;
-  const newSessionId = randomUUID();
+  const newSessionId = randomUUID2();
   session.claudeSessionId = newSessionId;
   const cliOptions = {
     workingDir: absoluteDir,
@@ -19626,6 +20003,11 @@ async function inviteUser(session, invitedUser, invitedBy, ctx) {
   if (!await requireSessionOwner(session, invitedBy, "invite others")) {
     return;
   }
+  const user = await session.platform.getUserByUsername(invitedUser);
+  if (!user) {
+    await postWarning(session, `User @${invitedUser} does not exist on this platform`);
+    return;
+  }
   session.sessionAllowedUsers.add(invitedUser);
   await postSuccess(session, `@${invitedUser} can now participate in this session (invited by @${invitedBy})`);
   log9.info(`\uD83D\uDC4B @${invitedUser} invited to session by @${invitedBy}`);
@@ -19636,6 +20018,11 @@ async function kickUser(session, kickedUser, kickedBy, ctx) {
   if (!await requireSessionOwner(session, kickedBy, "kick others")) {
     return;
   }
+  const user = await session.platform.getUserByUsername(kickedUser);
+  if (!user) {
+    await postWarning(session, `User @${kickedUser} does not exist on this platform`);
+    return;
+  }
   if (kickedUser === session.startedBy) {
     await postWarning(session, `Cannot kick session owner @${session.startedBy}`);
     return;
@@ -19749,6 +20136,17 @@ async function updateSessionHeader(session, ctx) {
   if (session.worktreeInfo) {
     const shortRepoRoot = session.worktreeInfo.repoRoot.replace(process.env.HOME || "", "~");
     rows.push(`| \uD83C\uDF3F **Worktree** | \`${session.worktreeInfo.branch}\` (from \`${shortRepoRoot}\`) |`);
+  } else {
+    const isRepo = await isGitRepository(session.workingDir);
+    if (isRepo) {
+      const branch = await getCurrentBranch(session.workingDir);
+      if (branch) {
+        rows.push(`| \uD83C\uDF3F **Branch** | \`${branch}\` |`);
+      }
+    }
+  }
+  if (session.pullRequestUrl) {
+    rows.push(`| \uD83D\uDD17 **Pull Request** | ${formatPullRequestLink(session.pullRequestUrl)} |`);
   }
   if (otherParticipants) {
     rows.push(`| \uD83D\uDC65 **Participants** | ${otherParticipants} |`);
@@ -19779,8 +20177,8 @@ async function updateSessionHeader(session, ctx) {
 }
 
 // src/session/lifecycle.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync7 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync8 } from "fs";
 var log10 = createLogger("lifecycle");
 function mutableSessions(ctx) {
   return ctx.state.sessions;
@@ -19903,7 +20301,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
     return;
   const actualThreadId = replyToPostId || post.id;
   const sessionId = ctx.ops.getSessionId(platformId, actualThreadId);
-  const claudeSessionId = randomUUID2();
+  const claudeSessionId = randomUUID3();
   const platformMcpConfig = platform.getMcpConfig();
   const cliOptions = {
     workingDir: ctx.config.workingDir,
@@ -20012,7 +20410,7 @@ async function resumeSession(state, ctx) {
     log10.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
-  if (!existsSync7(state.workingDir)) {
+  if (!existsSync8(state.workingDir)) {
     log10.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     await withErrorHandling(() => platform.createPost(`\u26A0\uFE0F **Cannot resume session** - working directory no longer exists:
@@ -20080,6 +20478,7 @@ Please start a new session.`, state.threadId), { action: "Post resume failure no
     needsContextPromptOnNextMessage: state.needsContextPromptOnNextMessage,
     sessionTitle: state.sessionTitle,
     sessionDescription: state.sessionDescription,
+    pullRequestUrl: state.pullRequestUrl,
     messageCount: state.messageCount ?? 0,
     statusBarTimer: null
   };
@@ -20225,7 +20624,7 @@ async function killSession(session, unpersist, ctx) {
   cleanupPostIndex(ctx, session.threadId);
   keepAlive.sessionEnded();
   if (unpersist) {
-    ctx.ops.unpersistSession(session.threadId);
+    ctx.ops.unpersistSession(session.sessionId);
   }
   log10.info(`\u2716 Session killed (${shortId}\u2026) \u2014 ${ctx.state.sessions.size} active`);
   await ctx.ops.updateStickyMessage();
@@ -20270,162 +20669,6 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
   }
 }
 
-// src/git/worktree.ts
-import { spawn as spawn4 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
-import * as path9 from "path";
-import * as fs5 from "fs/promises";
-async function execGit(args, cwd) {
-  return new Promise((resolve6, reject) => {
-    const proc = spawn4("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) {
-        resolve6(stdout.trim());
-      } else {
-        reject(new Error(`git ${args.join(" ")} failed: ${stderr || stdout}`));
-      }
-    });
-    proc.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-async function isGitRepository(dir) {
-  try {
-    await execGit(["rev-parse", "--git-dir"], dir);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getRepositoryRoot(dir) {
-  return execGit(["rev-parse", "--show-toplevel"], dir);
-}
-async function hasUncommittedChanges(dir) {
-  try {
-    const staged = await execGit(["diff", "--cached", "--quiet"], dir).catch(() => "changes");
-    if (staged === "changes")
-      return true;
-    const unstaged = await execGit(["diff", "--quiet"], dir).catch(() => "changes");
-    if (unstaged === "changes")
-      return true;
-    const untracked = await execGit(["ls-files", "--others", "--exclude-standard"], dir);
-    return untracked.length > 0;
-  } catch {
-    return false;
-  }
-}
-async function listWorktrees(repoRoot) {
-  const output = await execGit(["worktree", "list", "--porcelain"], repoRoot);
-  const worktrees = [];
-  if (!output)
-    return worktrees;
-  const blocks = output.split(`
-
-`).filter(Boolean);
-  for (const block of blocks) {
-    const lines = block.split(`
-`);
-    const worktree = {};
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        worktree.path = line.slice(9);
-      } else if (line.startsWith("HEAD ")) {
-        worktree.commit = line.slice(5);
-      } else if (line.startsWith("branch ")) {
-        worktree.branch = line.slice(7).replace("refs/heads/", "");
-      } else if (line === "bare") {
-        worktree.isBare = true;
-      } else if (line === "detached") {
-        worktree.branch = "(detached)";
-      }
-    }
-    if (worktree.path) {
-      worktrees.push({
-        path: worktree.path,
-        branch: worktree.branch || "(unknown)",
-        commit: worktree.commit || "",
-        isMain: worktrees.length === 0,
-        isBare: worktree.isBare || false
-      });
-    }
-  }
-  return worktrees;
-}
-async function branchExists(repoRoot, branch) {
-  try {
-    await execGit(["rev-parse", "--verify", `refs/heads/${branch}`], repoRoot);
-    return true;
-  } catch {
-    try {
-      await execGit(["rev-parse", "--verify", `refs/remotes/origin/${branch}`], repoRoot);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-function getWorktreeDir(repoRoot, branch) {
-  const repoName = path9.basename(repoRoot);
-  const parentDir = path9.dirname(repoRoot);
-  const worktreesDir = path9.join(parentDir, `${repoName}-worktrees`);
-  const sanitizedBranch = branch.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "");
-  const shortUuid = randomUUID3().slice(0, 8);
-  return path9.join(worktreesDir, `${sanitizedBranch}-${shortUuid}`);
-}
-async function createWorktree(repoRoot, branch, targetDir) {
-  const parentDir = path9.dirname(targetDir);
-  await fs5.mkdir(parentDir, { recursive: true });
-  const exists = await branchExists(repoRoot, branch);
-  if (exists) {
-    await execGit(["worktree", "add", targetDir, branch], repoRoot);
-  } else {
-    await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
-  }
-  return targetDir;
-}
-async function removeWorktree(repoRoot, worktreePath) {
-  try {
-    await execGit(["worktree", "remove", worktreePath], repoRoot);
-  } catch {
-    await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
-  }
-  await execGit(["worktree", "prune"], repoRoot);
-}
-async function findWorktreeByBranch(repoRoot, branch) {
-  const worktrees = await listWorktrees(repoRoot);
-  return worktrees.find((wt) => wt.branch === branch) || null;
-}
-function isValidBranchName(name) {
-  if (!name || name.length === 0)
-    return false;
-  if (name.startsWith("/") || name.endsWith("/"))
-    return false;
-  if (name.includes(".."))
-    return false;
-  if (/[\s~^:?*[\]\\]/.test(name))
-    return false;
-  if (name.startsWith("-"))
-    return false;
-  if (name.endsWith(".lock"))
-    return false;
-  if (name.includes("@{"))
-    return false;
-  if (name === "@")
-    return false;
-  if (/\.\./.test(name))
-    return false;
-  return true;
-}
-
 // src/session/worktree.ts
 import { randomUUID as randomUUID4 } from "crypto";
 var log11 = createLogger("worktree");
@@ -20993,6 +21236,26 @@ function getSessionTopic(session) {
   }
   return formatTopicFromPrompt(session.firstPrompt);
 }
+function getHistorySessionTopic(session) {
+  if (session.sessionTitle) {
+    return session.sessionTitle;
+  }
+  return formatTopicFromPrompt(session.firstPrompt);
+}
+function formatHistoryEntry(session) {
+  const topic = getHistorySessionTopic(session);
+  const threadLink = `[${topic}](/_redirect/pl/${session.threadId})`;
+  const displayName = session.startedByDisplayName || session.startedBy;
+  const cleanedAt = session.cleanedAt ? new Date(session.cleanedAt) : new Date(session.lastActivityAt);
+  const time = formatRelativeTime(cleanedAt);
+  const prStr = session.pullRequestUrl ? ` \xB7 ${formatPullRequestLink(session.pullRequestUrl)}` : "";
+  const lines = [];
+  lines.push(`  \u2713 ${threadLink} \xB7 **${displayName}**${prStr} \xB7 ${time}`);
+  if (session.sessionDescription) {
+    lines.push(`     _${session.sessionDescription}_`);
+  }
+  return lines;
+}
 async function buildStatusBar(sessionCount, config) {
   const items = [];
   items.push(`\`v${VERSION}\``);
@@ -21036,17 +21299,27 @@ function formatTopicFromPrompt(prompt) {
 async function buildStickyMessage(sessions, platformId, config) {
   const platformSessions = [...sessions.values()].filter((s) => s.platformId === platformId);
   const statusBar = await buildStatusBar(platformSessions.length, config);
+  const historySessions = sessionStore ? sessionStore.getHistory(platformId).slice(0, 5) : [];
   if (platformSessions.length === 0) {
-    return [
+    const lines2 = [
       "---",
       statusBar,
       "",
       "**Active Claude Threads**",
       "",
-      "_No active sessions_",
-      "",
-      "_Mention me to start a session_ \xB7 `npm i -g claude-threads`"
-    ].join(`
+      "_No active sessions_"
+    ];
+    if (historySessions.length > 0) {
+      lines2.push("");
+      lines2.push(`**Recent** (${historySessions.length})`);
+      lines2.push("");
+      for (const historySession of historySessions) {
+        lines2.push(...formatHistoryEntry(historySession));
+      }
+    }
+    lines2.push("");
+    lines2.push("_Mention me to start a session_ \xB7 `npm i -g claude-threads`");
+    return lines2.join(`
 `);
   }
   platformSessions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
@@ -21065,7 +21338,8 @@ async function buildStickyMessage(sessions, platformId, config) {
     const time = formatRelativeTime(session.startedAt);
     const taskProgress = getTaskProgress(session);
     const progressStr = taskProgress ? ` \xB7 ${taskProgress}` : "";
-    lines.push(`\u25B8 ${threadLink} \xB7 **${displayName}**${progressStr} \xB7 ${time}`);
+    const prStr = session.pullRequestUrl ? ` \xB7 ${formatPullRequestLink(session.pullRequestUrl)}` : "";
+    lines.push(`\u25B8 ${threadLink} \xB7 **${displayName}**${progressStr}${prStr} \xB7 ${time}`);
     if (session.sessionDescription) {
       lines.push(`   _${session.sessionDescription}_`);
     }
@@ -21078,6 +21352,14 @@ async function buildStickyMessage(sessions, platformId, config) {
       lines.push(`   \uD83D\uDD04 _${activeTask}_`);
     }
   }
+  if (historySessions.length > 0) {
+    lines.push("");
+    lines.push(`**Recent** (${historySessions.length})`);
+    lines.push("");
+    for (const historySession of historySessions) {
+      lines.push(...formatHistoryEntry(historySession));
+    }
+  }
   lines.push("");
   lines.push("_Mention me to start a session_ \xB7 `npm i -g claude-threads`");
   return lines.join(`
@@ -21505,12 +21787,13 @@ class SessionManager {
       timeoutPostId: session.timeoutPostId,
       sessionTitle: session.sessionTitle,
       sessionDescription: session.sessionDescription,
+      pullRequestUrl: session.pullRequestUrl,
       messageCount: session.messageCount
     };
     this.sessionStore.save(session.sessionId, state);
   }
   unpersistSession(sessionId) {
-    this.sessionStore.remove(sessionId);
+    this.sessionStore.softDelete(sessionId);
   }
   async updateSessionHeader(session) {
     await updateSessionHeader(session, this.getContext());
@@ -21537,7 +21820,11 @@ class SessionManager {
     }
     const staleIds = this.sessionStore.cleanStale(SESSION_TIMEOUT_MS * 2);
     if (staleIds.length > 0) {
-      log14.info(`\uD83E\uDDF9 Cleaned ${staleIds.length} stale session(s) from persistence`);
+      log14.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
+    }
+    const removedCount = this.sessionStore.cleanHistory();
+    if (removedCount > 0) {
+      log14.info(`\uD83D\uDDD1\uFE0F Permanently removed ${removedCount} old session(s) from history`);
     }
     const persisted = this.sessionStore.load();
     log14.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);

package/dist/statusline/writer.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// @bun
+
+// src/statusline/writer.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+var sessionId = process.argv[2];
+if (!sessionId) {
+  console.log("");
+  process.exit(0);
+}
+var input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  input += chunk;
+});
+process.stdin.on("end", () => {
+  try {
+    const data = JSON.parse(input);
+    const contextWindow = data.context_window;
+    if (contextWindow) {
+      const usage = contextWindow.current_usage;
+      const output = {
+        context_window_size: contextWindow.context_window_size,
+        total_input_tokens: contextWindow.total_input_tokens,
+        total_output_tokens: contextWindow.total_output_tokens,
+        current_usage: usage ? {
+          input_tokens: usage.input_tokens || 0,
+          output_tokens: usage.output_tokens || 0,
+          cache_creation_input_tokens: usage.cache_creation_input_tokens || 0,
+          cache_read_input_tokens: usage.cache_read_input_tokens || 0
+        } : null,
+        model: data.model ? {
+          id: data.model.id,
+          display_name: data.model.display_name
+        } : null,
+        cost: data.cost ? {
+          total_cost_usd: data.cost.total_cost_usd
+        } : null,
+        timestamp: Date.now()
+      };
+      const filePath = `/tmp/claude-threads-status-${sessionId}.json`;
+      mkdirSync(dirname(filePath), { recursive: true });
+      writeFileSync(filePath, JSON.stringify(output, null, 2));
+    }
+  } catch {}
+  console.log("");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "dev": "bun --watch src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target bun && bun build src/mcp/permission-server.ts --outdir dist/mcp --target bun",
+    "build": "bun build src/index.ts --outdir dist --target bun && bun build src/mcp/permission-server.ts --outdir dist/mcp --target bun && bun build src/statusline/writer.ts --outdir dist/statusline --target bun",
     "start": "bun dist/index.js",
     "test": "bun test",
     "test:watch": "bun test --watch",