claude-threads 1.36.0 → 1.37.0

package/dist/index.js

@@ -2128,6 +2128,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
+// src/utils/state-home.ts
+import { homedir } from "os";
+import { resolve } from "path";
+function stateHome() {
+  return resolve(process.env.CLAUDE_THREADS_HOME || homedir());
+}
+function hasStateHomeOverride() {
+  return stateHome() !== resolve(homedir());
+}
+var init_state_home = () => {};
+
 // src/utils/logger.ts
 function setLogHandler(handler) {
   globalLogHandler = handler;
@@ -2221,6 +2232,23 @@ function resolveOverheadVisibility(value, fieldPath) {
     return value;
   throw new Error(`Invalid ${fieldPath}: expected one of ${OVERHEAD_VISIBILITY_VALUES.join(", ")}, got ${JSON.stringify(value)}`);
 }
+function resolveTurnMarker(mode, emoji, platformType, fieldPath) {
+  const m = mode === undefined || mode === null ? "off" : mode;
+  if (!TURN_MARKER_VALUES.includes(m)) {
+    throw new Error(`Invalid ${fieldPath}.turnMarker: expected one of ${TURN_MARKER_VALUES.join(", ")}, got ${JSON.stringify(mode)}`);
+  }
+  if (m === "metadata" && platformType !== "slack") {
+    throw new Error(`Invalid ${fieldPath}.turnMarker: metadata is a Slack feature; use reaction on ${platformType}`);
+  }
+  if (emoji !== undefined && emoji !== null) {
+    if (typeof emoji !== "string" || !/^[a-z0-9_+-]+$/.test(emoji)) {
+      throw new Error(`Invalid ${fieldPath}.turnMarkerEmoji: expected an emoji name like checkered_flag, got ${JSON.stringify(emoji)}`);
+    }
+  }
+  if (m === "reaction")
+    return { mode: "reaction", emoji: emoji ?? DEFAULT_TURN_MARKER_EMOJI };
+  return { mode: m };
+}
 function resolveMemoryConfig(value, fieldPath) {
   if (value === undefined || value === null || value === true)
     return DEFAULT_MEMORY_CONFIG;
@@ -2395,10 +2423,12 @@ function effectivePermissionMode(input) {
     return "default";
   return input.botWideMode;
 }
-var OVERHEAD_VISIBILITY_VALUES, DEFAULT_OVERHEAD_VISIBILITY = "full", RECONNECT_POLICY_VALUES, DEFAULT_RECONNECT_POLICY = "retry", DEFAULT_MEMORY_CONFIG, MEMORY_DISABLED, BOT_MCP_SERVER_NAME = "claude-threads-mcp", STDIO_KEYS, REMOTE_KEYS, LIMITS_DEFAULTS, MODE_INFO;
+var OVERHEAD_VISIBILITY_VALUES, DEFAULT_OVERHEAD_VISIBILITY = "full", RECONNECT_POLICY_VALUES, DEFAULT_RECONNECT_POLICY = "retry", TURN_MARKER_VALUES, DEFAULT_TURN_MARKER, DEFAULT_TURN_MARKER_EMOJI = "checkered_flag", TURN_COMPLETE_EVENT_TYPE = "claude_threads_turn_complete", TURN_COMPLETE_PAYLOAD_VERSION = 1, DEFAULT_MEMORY_CONFIG, MEMORY_DISABLED, BOT_MCP_SERVER_NAME = "claude-threads-mcp", STDIO_KEYS, REMOTE_KEYS, LIMITS_DEFAULTS, MODE_INFO;
 var init_types = __esm(() => {
   OVERHEAD_VISIBILITY_VALUES = ["full", "minimal", "hidden"];
   RECONNECT_POLICY_VALUES = ["retry", "exit"];
+  TURN_MARKER_VALUES = ["reaction", "metadata", "off"];
+  DEFAULT_TURN_MARKER = { mode: "off" };
   DEFAULT_MEMORY_CONFIG = {
     enabled: true,
     repoLayer: true,
@@ -4597,7 +4627,7 @@ var init_rate_limit_detector = __esm(() => {
 
 // src/claude/cli.ts
 import { EventEmitter } from "events";
-import { resolve as resolve2, dirname as dirname2 } from "path";
+import { resolve as resolve3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync4, readFileSync as readFileSync2, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
@@ -5139,15 +5169,15 @@ var init_cli = __esm(() => {
     getMcpServerPath() {
       const __filename2 = fileURLToPath(import.meta.url);
       const __dirname2 = dirname2(__filename2);
-      const bundledPath = resolve2(__dirname2, "mcp", "mcp-server.js");
+      const bundledPath = resolve3(__dirname2, "mcp", "mcp-server.js");
       if (existsSync4(bundledPath)) {
         return bundledPath;
       }
-      const sourceLayoutPath = resolve2(__dirname2, "..", "mcp", "mcp-server.js");
+      const sourceLayoutPath = resolve3(__dirname2, "..", "mcp", "mcp-server.js");
       if (existsSync4(sourceLayoutPath)) {
         return sourceLayoutPath;
       }
-      const tsPath = resolve2(__dirname2, "..", "mcp", "mcp-server.ts");
+      const tsPath = resolve3(__dirname2, "..", "mcp", "mcp-server.ts");
       if (existsSync4(tsPath)) {
         return tsPath;
       }
@@ -5156,15 +5186,15 @@ var init_cli = __esm(() => {
     getStatusLineWriterPath() {
       const __filename2 = fileURLToPath(import.meta.url);
       const __dirname2 = dirname2(__filename2);
-      const bundledPath = resolve2(__dirname2, "statusline", "writer.js");
+      const bundledPath = resolve3(__dirname2, "statusline", "writer.js");
       if (existsSync4(bundledPath)) {
         return bundledPath;
       }
-      const sourceLayoutPath = resolve2(__dirname2, "..", "statusline", "writer.js");
+      const sourceLayoutPath = resolve3(__dirname2, "..", "statusline", "writer.js");
       if (existsSync4(sourceLayoutPath)) {
         return sourceLayoutPath;
       }
-      const tsPath = resolve2(__dirname2, "..", "statusline", "writer.ts");
+      const tsPath = resolve3(__dirname2, "..", "statusline", "writer.ts");
       if (existsSync4(tsPath)) {
         return tsPath;
       }
@@ -5411,7 +5441,7 @@ var init_render = __esm(() => {
 });
 
 // src/usage/index.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir2 } from "os";
 import path3 from "path";
 function toLimits(usage) {
   const limits = [
@@ -5461,7 +5491,7 @@ async function collectUsage(options) {
     }
     return results;
   }
-  const configDir = process.env.CLAUDE_CONFIG_DIR ?? path3.join(homedir5(), ".claude");
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? path3.join(homedir2(), ".claude");
   return [await readSeat(profileNameFor(configDir), configDir)];
 }
 var USAGE_PROBE_TIMEOUT_MS = 1e4;
@@ -5525,7 +5555,6 @@ var init_emoji = __esm(() => {
 import { randomUUID as randomUUID2 } from "crypto";
 import * as path4 from "path";
 import * as fs from "fs/promises";
-import { homedir as homedir6 } from "os";
 async function execGit(args, cwd) {
   const cmd = `git ${args.join(" ")}`;
   log10.debug(`Executing: ${cmd}`);
@@ -5834,10 +5863,11 @@ async function removeWorktreeMetadata(worktreePath) {
 var log10, WORKTREES_DIR, METADATA_STORE_PATH;
 var init_worktree = __esm(() => {
   init_spawn();
+  init_state_home();
   init_logger();
   log10 = createLogger("git-wt");
-  WORKTREES_DIR = path4.join(homedir6(), ".claude-threads", "worktrees");
-  METADATA_STORE_PATH = path4.join(homedir6(), ".claude-threads", "worktree-metadata.json");
+  WORKTREES_DIR = path4.join(stateHome(), ".claude-threads", "worktrees");
+  METADATA_STORE_PATH = path4.join(stateHome(), ".claude-threads", "worktree-metadata.json");
 });
 
 // node_modules/graceful-fs/polyfills.js
@@ -47494,17 +47524,17 @@ function resolveAckReaction(configured) {
 }
 
 // src/persistence/audit-log.ts
+init_state_home();
 init_logger();
 import { chmodSync, closeSync, constants as fsConstants, fchmodSync, lstatSync, mkdirSync, openSync, writeSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
 var log = createLogger("audit");
 var DETAIL_MAX = 500;
 var enabledPlatforms = new Set;
 var preparedDirs = new Set;
 var openFds = new Map;
 function auditDir() {
-  return process.env.CLAUDE_THREADS_AUDIT_DIR || join(homedir(), ".claude-threads", "audit");
+  return process.env.CLAUDE_THREADS_AUDIT_DIR || join(stateHome(), ".claude-threads", "audit");
 }
 function configureAuditLog(platformId, enabled) {
   if (enabled)
@@ -47612,6 +47642,20 @@ function deriveDmPlatformConfig(parent, channelId, partnerUsernames) {
   };
 }
 
+// src/session/lifecycle-visibility.ts
+function shouldPostLifecycle(visibility, kind) {
+  if (kind === "abnormal-exit")
+    return true;
+  switch (visibility) {
+    case "full":
+      return true;
+    case "minimal":
+      return kind !== "idle-warning";
+    case "hidden":
+      return false;
+  }
+}
+
 // src/session/lifecycle-fsm.ts
 init_logger();
 var log2 = createLogger("fsm");
@@ -47718,9 +47762,9 @@ function getSessionStatus(session) {
 }
 
 // src/config/index.ts
+init_state_home();
 import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
-import { resolve, dirname } from "path";
-import { homedir as homedir2 } from "os";
+import { resolve as resolve2, dirname } from "path";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 function getDefaultExportFromCjs(x) {
@@ -50889,7 +50933,7 @@ function resolvePlatformMcpPosture(platforms, globalMcpServers, managedPresent =
 }
 
 // src/config/index.ts
-var CONFIG_PATH = resolve(homedir2(), ".config", "claude-threads", "config.yaml");
+var CONFIG_PATH = resolve2(stateHome(), ".config", "claude-threads", "config.yaml");
 function loadConfigWithMigration() {
   if (existsSync2(CONFIG_PATH)) {
     const content = readFileSync(CONFIG_PATH, "utf-8");
@@ -51072,7 +51116,6 @@ function writeFileAtomic(file, content) {
 
 // src/persistence/session-store.ts
 init_logger();
-import { homedir as homedir3 } from "os";
 import { join as join5 } from "path";
 
 // src/sponsor.ts
@@ -51097,6 +51140,7 @@ function formatMilestoneLine(formatter, milestone) {
 }
 
 // src/persistence/session-store.ts
+init_state_home();
 var log4 = createLogger("persist");
 function resolveEndReason(session) {
   if (!session.cleanedAt)
@@ -51107,7 +51151,7 @@ function isRevivable(session) {
   return resolveEndReason(session) !== "stopped";
 }
 var STORE_VERSION = 2;
-var DEFAULT_CONFIG_DIR = join5(homedir3(), ".config", "claude-threads");
+var DEFAULT_CONFIG_DIR = join5(stateHome(), ".config", "claude-threads");
 var DEFAULT_SESSIONS_FILE = join5(DEFAULT_CONFIG_DIR, "sessions.json");
 
 class SessionStore {
@@ -51384,12 +51428,12 @@ class SessionStore {
 }
 
 // src/persistence/thread-logger.ts
+init_state_home();
 init_logger();
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync4, chmodSync as chmodSync4 } from "fs";
-import { homedir as homedir4 } from "os";
 import { join as join6, dirname as dirname3 } from "path";
 var log5 = createLogger("thread-log");
-var LOGS_BASE_DIR = join6(homedir4(), ".claude-threads", "logs");
+var LOGS_BASE_DIR = join6(stateHome(), ".claude-threads", "logs");
 
 class ThreadLoggerImpl {
   platformId;
@@ -51661,14 +51705,14 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
 
 // src/version.ts
 import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { dirname as dirname4, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
 function loadPackageJson() {
   const candidates = [
-    resolve3(__dirname2, "..", "package.json"),
-    resolve3(__dirname2, "..", "..", "package.json"),
-    resolve3(process.cwd(), "package.json")
+    resolve4(__dirname2, "..", "package.json"),
+    resolve4(__dirname2, "..", "..", "package.json"),
+    resolve4(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
     if (existsSync7(candidate)) {
@@ -52136,13 +52180,13 @@ ${formatter.formatBold("Reactions:")}
 
 // src/changelog.ts
 import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
-import { dirname as dirname5, resolve as resolve4 } from "path";
+import { dirname as dirname5, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
 function getReleaseNotes(version) {
   const possiblePaths = [
-    resolve4(__dirname3, "..", "CHANGELOG.md"),
-    resolve4(__dirname3, "..", "..", "CHANGELOG.md")
+    resolve5(__dirname3, "..", "CHANGELOG.md"),
+    resolve5(__dirname3, "..", "..", "CHANGELOG.md")
   ];
   let changelogPath = null;
   for (const p of possiblePaths) {
@@ -53278,15 +53322,21 @@ async function postError(session, message, addBugReaction = true) {
   }
   return result;
 }
-async function postInteractive(session, message, reactions) {
-  const post = await session.platform.createInteractivePost(message, reactions, session.threadId);
-  updateLastMessage(session, post);
-  return post;
+async function postInteractive(session, message, reactions, onPostCreated) {
+  const doneInFlight = typeof session.messageManager?.markInteractivePostInFlight === "function" ? session.messageManager.markInteractivePostInFlight() : () => {};
+  try {
+    const post = await session.platform.createInteractivePost(message, reactions, session.threadId, (created) => {
+      onPostCreated?.(created);
+      doneInFlight();
+    });
+    updateLastMessage(session, post);
+    return post;
+  } finally {
+    doneInFlight();
+  }
 }
 async function postInteractiveAndRegister(session, message, reactions, registerPost) {
-  const post = await postInteractive(session, message, reactions);
-  registerPost(post.id, session.threadId);
-  return post;
+  return postInteractive(session, message, reactions, (created) => registerPost(created.id, session.threadId));
 }
 async function updatePost(session, postId, message) {
   await withErrorHandling(() => session.platform.updatePost(postId, message), { action: "Update post", session });
@@ -53326,6 +53376,8 @@ function updateLastMessage(session, post) {
 init_cli();
 
 // src/operations/streaming/handler.ts
+init_state_home();
+import { createHash } from "crypto";
 import { lstat, mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join8 } from "path";
@@ -53462,7 +53514,12 @@ function safeIdSegment(id) {
   return id.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function getSessionUploadDir(platformId, threadId) {
-  return join8(tmpdir3(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
+  return join8(tmpdir3(), UPLOAD_ROOT_DIR, `${instancePrefix()}${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
+}
+function instancePrefix() {
+  if (!hasStateHomeOverride())
+    return "";
+  return createHash("sha1").update(stateHome()).digest("hex").slice(0, 12) + "-";
 }
 async function cleanupSessionUploads(platformId, threadId) {
   if (!platformId || !threadId)
@@ -53670,7 +53727,7 @@ function buildRestartCliOptions(session, ctx) {
 
 // src/operations/commands/handler.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { existsSync as existsSync12, statSync as statSync4 } from "fs";
 
 // node_modules/update-notifier/update-notifier.js
@@ -57680,8 +57737,8 @@ function checkGitHubCli(exec = execSync2) {
   }
   return { installed: true, authenticated: true };
 }
-async function createGitHubIssue(title, body, workingDir) {
-  const ghStatus = checkGitHubCli();
+async function createGitHubIssue(title, body, workingDir, exec = execSync2) {
+  const ghStatus = checkGitHubCli(exec);
   if (!ghStatus.installed || !ghStatus.authenticated) {
     throw new Error(ghStatus.error);
   }
@@ -57689,7 +57746,7 @@ async function createGitHubIssue(title, body, workingDir) {
   try {
     writeFileSync5(bodyFile, body, "utf-8");
     const cmd = `gh issue create --repo "${GITHUB_REPO}" --title "${escapeShell(title)}" --body-file "${bodyFile}"`;
-    const result = execSync2(cmd, {
+    const result = exec(cmd, {
       cwd: workingDir,
       encoding: "utf-8",
       timeout: 30000,
@@ -59621,12 +59678,13 @@ function createAppendContentOp(sessionId, content, isToolOutput) {
     isToolOutput
   };
 }
-function createFlushOp(sessionId, reason) {
+function createFlushOp(sessionId, reason, resultOk) {
   return {
     type: "flush",
     sessionId,
     timestamp: Date.now(),
-    reason
+    reason,
+    ...resultOk === undefined ? {} : { resultOk }
   };
 }
 function createTaskListOp(sessionId, action, tasks, toolUseId) {
@@ -59681,6 +59739,7 @@ function createStatusUpdateOp(sessionId, options) {
   };
 }
 // src/operations/transformer.ts
+init_cli();
 function transformEvent(event, ctx) {
   if (event.parent_tool_use_id) {
     return [];
@@ -59843,7 +59902,7 @@ function transformToolResult(event, ctx) {
 }
 function transformResult(event, ctx) {
   const operations = [];
-  operations.push(createFlushOp(ctx.sessionId, "result"));
+  operations.push(createFlushOp(ctx.sessionId, "result", !isErrorResultEvent(event)));
   const result = event;
   const r = result.result;
   operations.push(createStatusUpdateOp(ctx.sessionId, {
@@ -59926,6 +59985,9 @@ function truncateAtWord2(text, maxLength) {
   }
   return truncated + "...";
 }
+// src/operations/message-manager.ts
+init_types();
+
 // src/operations/task-tracker.ts
 var VALID_STATUSES = new Set(["pending", "in_progress", "completed"]);
 var CREATED_RESULT_RE = /Task #(\S+) created/;
@@ -61156,16 +61218,26 @@ class QuestionApprovalExecutor extends BaseExecutor {
 
 ` + ctx.formatter.formatItalic("React to respond");
     }
+    let claimed = false;
     const post = await ctx.createInteractivePost(message, [APPROVAL_EMOJIS[0], DENIAL_EMOJIS[0]], {
       type: "plan_approval",
       interactionType: "plan_approval",
       toolUseId: op.toolUseId
+    }, (created) => {
+      claimed = true;
+      this.state.pendingApproval = {
+        postId: created.id,
+        type: op.approvalType,
+        toolUseId: op.toolUseId
+      };
     });
-    this.state.pendingApproval = {
-      postId: post.id,
-      type: op.approvalType,
-      toolUseId: op.toolUseId
-    };
+    if (!claimed) {
+      this.state.pendingApproval = {
+        postId: post.id,
+        type: op.approvalType,
+        toolUseId: op.toolUseId
+      };
+    }
     ctx.logger.debug(`Created ${op.approvalType} approval post ${formatShortId(post.id)}`);
   }
   async postCurrentQuestion(ctx) {
@@ -61191,13 +61263,21 @@ class QuestionApprovalExecutor extends BaseExecutor {
       message += `
 `;
     }
+    let claimed = false;
     const reactionOptions = NUMBER_EMOJIS.slice(0, q.options.length);
     const post = await ctx.createInteractivePost(message, reactionOptions, {
       type: "question",
       interactionType: "question",
       toolUseId: this.state.pendingQuestionSet.toolUseId
+    }, (created) => {
+      claimed = true;
+      if (this.state.pendingQuestionSet) {
+        this.state.pendingQuestionSet.currentPostId = created.id;
+      }
     });
-    this.state.pendingQuestionSet.currentPostId = post.id;
+    if (!claimed && this.state.pendingQuestionSet) {
+      this.state.pendingQuestionSet.currentPostId = post.id;
+    }
   }
   async handleQuestionAnswer(postId, optionIndex, ctx) {
     if (!this.state.pendingQuestionSet)
@@ -61867,6 +61947,9 @@ class MessageManager {
   platform;
   postTracker;
   contentBreaker;
+  turnMarker;
+  flushInFlight = null;
+  turn = 0;
   session;
   contentExecutor;
   taskListExecutor;
@@ -61881,6 +61964,7 @@ class MessageManager {
   worktreePath;
   worktreeBranch;
   registerPost;
+  beginInteractivePost;
   updateLastMessage;
   buildMessageContentCallback;
   startTypingCallback;
@@ -61902,11 +61986,13 @@ class MessageManager {
     this.worktreePath = options.worktreePath;
     this.worktreeBranch = options.worktreeBranch;
     this.registerPost = options.registerPost;
+    this.beginInteractivePost = options.beginInteractivePost;
     this.updateLastMessage = options.updateLastMessage;
     this.buildMessageContentCallback = options.buildMessageContent;
     this.startTypingCallback = options.startTyping;
     this.emitSessionUpdateCallback = options.emitSessionUpdate;
     this.flushDelayMs = options.flushDelayMs ?? MessageManager.DEFAULT_FLUSH_DELAY_MS;
+    this.turnMarker = options.turnMarker ?? { mode: "off" };
     this.events = createMessageManagerEvents();
     this.contentBreaker = new DefaultContentBreaker;
     this.contentExecutor = new ContentExecutor({
@@ -62048,15 +62134,58 @@ class MessageManager {
   }
   async handleFlushOp(op, ctx) {
     this.cancelScheduledFlush();
-    await this.contentExecutor.executeFlush(op, ctx);
+    if (this.flushInFlight)
+      await this.flushInFlight.catch(() => {
+        return;
+      });
+    if (op.reason === "result")
+      this.turn++;
+    await this.runTrackedFlush(op, ctx);
+    if (op.reason === "result") {
+      await this.markTurnComplete(ctx, op.resultOk !== false);
+    }
+  }
+  async markTurnComplete(ctx, ok) {
+    if (this.turnMarker.mode === "off")
+      return;
+    const { currentPostId, currentPostContent } = this.contentExecutor.getState();
+    if (!currentPostId)
+      return;
+    try {
+      if (this.turnMarker.mode === "metadata") {
+        await this.platform.updatePost(currentPostId, currentPostContent, {
+          metadata: {
+            event_type: TURN_COMPLETE_EVENT_TYPE,
+            event_payload: { v: TURN_COMPLETE_PAYLOAD_VERSION, session: this.sessionId, turn: this.turn, ok }
+          }
+        });
+      } else {
+        await this.platform.addReaction(currentPostId, this.turnMarker.emoji ?? "checkered_flag");
+      }
+    } catch (err) {
+      const message = err.message ?? String(err);
+      if (this.turnMarker.mode === "reaction" && message.includes("already_reacted"))
+        return;
+      ctx.logger.warn(`turn marker (${this.turnMarker.mode}) failed on ${currentPostId}: ${message}`);
+    }
+  }
+  async runTrackedFlush(op, ctx) {
+    const running = this.contentExecutor.executeFlush(op, ctx).finally(() => {
+      if (this.flushInFlight === running)
+        this.flushInFlight = null;
+    });
+    this.flushInFlight = running;
+    await running;
   }
   scheduleFlush(ctx) {
     if (this.flushTimer)
       return;
-    this.flushTimer = setTimeout(async () => {
+    this.flushTimer = setTimeout(() => {
       this.flushTimer = null;
       const flushOp = createFlushOp(this.sessionId, "soft_threshold");
-      await this.contentExecutor.executeFlush(flushOp, ctx);
+      this.runTrackedFlush(flushOp, ctx).catch(() => {
+        return;
+      });
     }, this.flushDelayMs);
   }
   cancelScheduledFlush() {
@@ -62067,8 +62196,12 @@ class MessageManager {
   }
   async flush() {
     this.cancelScheduledFlush();
+    if (this.flushInFlight)
+      await this.flushInFlight.catch(() => {
+        return;
+      });
     const flushOp = createFlushOp(this.sessionId, "explicit");
-    await this.contentExecutor.executeFlush(flushOp, this.getExecutorContext());
+    await this.runTrackedFlush(flushOp, this.getExecutorContext());
   }
   getExecutorContext() {
     return {
@@ -62086,14 +62219,25 @@ class MessageManager {
         this.updateLastMessage(post);
         return post;
       },
-      createInteractivePost: async (content, reactions, options) => {
-        const post = await this.platform.createInteractivePost(content, reactions, this.threadId);
-        this.registerPost(post.id, options);
-        this.updateLastMessage(post);
-        return post;
+      createInteractivePost: async (content, reactions, options, onPostCreated) => {
+        const doneInFlight = this.beginInteractivePost?.(this.threadId);
+        try {
+          const post = await this.platform.createInteractivePost(content, reactions, this.threadId, (created) => {
+            this.registerPost(created.id, options);
+            doneInFlight?.();
+            onPostCreated?.(created);
+          });
+          this.updateLastMessage(post);
+          return post;
+        } finally {
+          doneInFlight?.();
+        }
       }
     };
   }
+  markInteractivePostInFlight() {
+    return this.beginInteractivePost?.(this.threadId) ?? (() => {});
+  }
   setWorktreeInfo(path, branch) {
     this.worktreePath = path;
     this.worktreeBranch = branch;
@@ -62602,12 +62746,12 @@ function formatHistoryEntry(session, formatter, getThreadLink) {
   const topic = getHistorySessionTopic(session, formatter);
   const threadLink = formatter.formatLink(topic, getThreadLink(session.threadId));
   const displayName = session.startedByDisplayName || session.startedBy;
-  const isTimedOut = isRevivable(session) && session.lifecyclePostId;
+  const isTimedOut = isRevivable(session);
   const lastActivity = new Date(session.lastActivityAt);
   const time = formatRelativeTimeShort(lastActivity);
   const prStr = session.pullRequestUrl ? ` · ${formatPullRequestLink(session.pullRequestUrl, formatter)}` : "";
   const indicator = isTimedOut ? "⏸️" : "✓";
-  const resumeHint = isTimedOut ? ` · ${formatter.formatItalic("react \uD83D\uDD04 to resume")}` : "";
+  const resumeHint = isTimedOut ? ` · ${formatter.formatItalic(session.lifecyclePostId ? "react \uD83D\uDD04 to resume" : "send a message to resume")}` : "";
   const lines = [];
   lines.push(`  ${indicator} ${threadLink} · ${formatter.formatBold(displayName)}${prStr} · ${time}${resumeHint}`);
   if (session.sessionDescription) {
@@ -63064,19 +63208,19 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
   }
 }
 // src/memory/store.ts
-import { createHash } from "crypto";
+init_state_home();
+import { createHash as createHash2 } from "crypto";
 import {
   existsSync as existsSync9,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync7,
   realpathSync
 } from "fs";
-import { homedir as homedir7 } from "os";
 import { basename as basename3, dirname as dirname7, join as join10, sep as sep2 } from "path";
 init_logger();
 init_worktree();
 var log18 = createLogger("memory");
-var DEFAULT_ROOT = join10(homedir7(), ".config", "claude-threads", "memory");
+var DEFAULT_ROOT = join10(stateHome(), ".config", "claude-threads", "memory");
 var CHANNEL_BLOCK_MAX_LINES = 200;
 var CHANNEL_BLOCK_MAX_BYTES = 25 * 1024;
 var CHANNEL_FILE_MAX_ENTRIES = 400;
@@ -63087,7 +63231,7 @@ function safeIdSegment2(id) {
   return id.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function shortHash(value, length) {
-  return createHash("sha256").update(value).digest("hex").slice(0, length);
+  return createHash2("sha256").update(value).digest("hex").slice(0, length);
 }
 function platformSegment(platformId) {
   return `${safeIdSegment2(platformId) || "platform"}-${shortHash(platformId, 6)}`;
@@ -63467,10 +63611,10 @@ import { join as join12 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/persistence/platform-list-store.ts
+init_state_home();
 import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
-import { homedir as homedir8 } from "os";
 import { join as join11 } from "path";
-var STORES_CONFIG_DIR = join11(homedir8(), ".config", "claude-threads");
+var STORES_CONFIG_DIR = join11(stateHome(), ".config", "claude-threads");
 var STORE_VERSION2 = 1;
 
 class PlatformListStore {
@@ -65658,12 +65802,12 @@ async function suggestSessionMetadata(context) {
 init_quick_query();
 
 // src/persistence/github-emails-store.ts
+init_state_home();
 import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "fs";
-import { homedir as homedir9 } from "os";
 import { join as join14 } from "path";
 init_logger();
 var log33 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR2 = join14(homedir9(), ".config", "claude-threads");
+var DEFAULT_CONFIG_DIR2 = join14(stateHome(), ".config", "claude-threads");
 var DEFAULT_FILE3 = join14(DEFAULT_CONFIG_DIR2, "github-emails.yaml");
 var NOREPLY_REGEX = /^\d+\+[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})@users\.noreply\.github\.com$/;
 var STORE_VERSION3 = 1;
@@ -65923,7 +66067,7 @@ async function changeDirectory(session, newDir, username, ctx) {
     return;
   }
   const expandedDir = newDir.startsWith("~") ? newDir.replace("~", process.env.HOME || "") : newDir;
-  const absoluteDir = resolve6(expandedDir);
+  const absoluteDir = resolve7(expandedDir);
   const formatter = session.platform.getFormatter();
   if (!existsSync12(absoluteDir)) {
     await postError(session, `Directory does not exist: ${formatter.formatCode(newDir)}`);
@@ -66414,7 +66558,7 @@ async function reportBug(session, description, username, ctx, errorContext, atta
   });
   sessionLog8(session).info(`\uD83D\uDC1B Bug report preview created by @${username}: ${title}`);
 }
-async function handleBugReportApproval(session, isApproved, username, ctx) {
+async function handleBugReportApproval(session, isApproved, username, ctx, exec) {
   const pending = session.messageManager?.getPendingBugReport();
   if (!pending)
     return;
@@ -66424,7 +66568,7 @@ async function handleBugReportApproval(session, isApproved, username, ctx) {
   const formatter = session.platform.getFormatter();
   if (isApproved) {
     try {
-      const issueUrl = await createGitHubIssue(pending.title, pending.body, session.workingDir);
+      const issueUrl = await createGitHubIssue(pending.title, pending.body, session.workingDir, exec);
       await updatePostSuccess(session, pending.postId, `${formatter.formatBold("Bug report submitted")}: ${issueUrl}`);
       sessionLog8(session).info(`\uD83D\uDC1B Bug report created by @${username}: ${issueUrl}`);
     } catch (err) {
@@ -66727,6 +66871,60 @@ class SessionRegistry {
   }
   registerPost(postId, threadId) {
     this.postIndex.set(postId, threadId);
+    const waiters = this.pendingPostWaiters.get(postId);
+    if (waiters) {
+      this.pendingPostWaiters.delete(postId);
+      for (const resolve of waiters)
+        resolve();
+    }
+  }
+  inFlightInteractivePosts = new Map;
+  pendingPostWaiters = new Map;
+  hasInFlightInteractivePost() {
+    return this.inFlightInteractivePosts.size > 0;
+  }
+  beginInteractivePost(threadId) {
+    this.inFlightInteractivePosts.set(threadId, (this.inFlightInteractivePosts.get(threadId) ?? 0) + 1);
+    let done = false;
+    return () => {
+      if (done)
+        return;
+      done = true;
+      const depth = (this.inFlightInteractivePosts.get(threadId) ?? 1) - 1;
+      if (depth <= 0)
+        this.inFlightInteractivePosts.delete(threadId);
+      else
+        this.inFlightInteractivePosts.set(threadId, depth);
+    };
+  }
+  async awaitPendingPost(postId, timeoutMs) {
+    if (this.postIndex.has(postId))
+      return;
+    if (!this.hasInFlightInteractivePost())
+      return;
+    await new Promise((resolve) => {
+      const waiters = this.pendingPostWaiters.get(postId) ?? [];
+      let settled = false;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        const list = this.pendingPostWaiters.get(postId);
+        if (list) {
+          const idx = list.indexOf(finish);
+          if (idx >= 0)
+            list.splice(idx, 1);
+          if (list.length === 0)
+            this.pendingPostWaiters.delete(postId);
+        }
+        resolve();
+      };
+      const timer = setTimeout(finish, timeoutMs);
+      timer.unref?.();
+      waiters.push(finish);
+      this.pendingPostWaiters.set(postId, waiters);
+    });
   }
   unregisterPost(postId) {
     this.postIndex.delete(postId);
@@ -67244,10 +67442,12 @@ function createMessageManager(session, ctx) {
     sessionId: session.sessionId,
     worktreePath: session.worktreeInfo?.worktreePath,
     worktreeBranch: session.worktreeInfo?.branch,
+    turnMarker: ctx.ops.getPlatformOverhead(session.platformId).turnMarker,
     registerPost: (postId, options) => {
       ctx.ops.registerPost(postId, session.threadId);
       postTracker.register(postId, session.threadId, session.sessionId, options);
     },
+    beginInteractivePost: (threadId) => ctx.ops.beginInteractivePost(threadId),
     updateLastMessage: (post) => {
       updateLastMessage(session, post);
     },
@@ -67885,7 +68085,7 @@ ${sessionFormatter.formatItalic(outcome)}`;
       await withErrorHandling(() => session.platform.updatePost(postId, resumeMsg), { action: "Update timeout/shutdown post for resume", session });
       session.lifecyclePostId = undefined;
       transitionTo(session, "active");
-    } else {
+    } else if (shouldPostLifecycle(ctx.ops.getPlatformOverhead(session.platformId).lifecycle, "resumed")) {
       const suffix = trigger === "platform-enabled" ? " (platform re-enabled)" : ` after bot restart (v${VERSION})`;
       const restartMsg = `${sessionFormatter.formatBold("Session resumed")}${suffix}
 ${sessionFormatter.formatItalic(outcome)}`;
@@ -68022,7 +68222,7 @@ async function handleExit(sessionId, code, ctx, source) {
     cleanupSessionTimers(session);
     await closeThreadLogger(session, "interrupt", { exitCode: code }, "pause");
     const message = session.lifecycle.hasClaudeResponded ? `ℹ️ Session paused. Send a new message to continue.` : `ℹ️ Session ended before Claude could respond. Send a new message to start fresh.`;
-    const pausePost = await withErrorHandling(() => post(session, "info", message), { action: "Post session pause notification", session });
+    const pausePost = shouldPostLifecycle(ctx.ops.getPlatformOverhead(session.platformId).lifecycle, "paused") ? await withErrorHandling(() => post(session, "info", message), { action: "Post session pause notification", session }) : null;
     if (session.lifecycle.hasClaudeResponded) {
       transitionTo(session, "paused");
       if (pausePost) {
@@ -68101,7 +68301,7 @@ Please start a new session.`), { action: "Post session permanent failure", sessi
     await session.platform.unpinPost(exitTaskState.postId).catch(() => {});
   }
   await ctx.ops.flush(session);
-  if (code !== 0 && code !== null) {
+  if (code !== 0 && code !== null && shouldPostLifecycle(ctx.ops.getPlatformOverhead(session.platformId).lifecycle, "abnormal-exit")) {
     const exitFormatter = session.platform.getFormatter();
     await post(session, "info", exitFormatter.formatBold(`[Exited: ${code}]`));
   }
@@ -68175,7 +68375,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
         const postId = session.lifecyclePostId;
         await withErrorHandling(() => session.platform.updatePost(postId, `⏱️ ${timeoutMessage}`), { action: "Update timeout post", session });
       } else {
-        const timeoutPost = await withErrorHandling(() => post(session, "timeout", timeoutMessage), { action: "Post session timeout", session });
+        const timeoutPost = shouldPostLifecycle(ctx.ops.getPlatformOverhead(session.platformId).lifecycle, "timed-out") ? await withErrorHandling(() => post(session, "timeout", timeoutMessage), { action: "Post session timeout", session }) : null;
         if (timeoutPost) {
           session.lifecyclePostId = timeoutPost.id;
           ctx.ops.registerPost(timeoutPost.id, session.threadId);
@@ -68188,7 +68388,8 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
       continue;
     }
     const warningThresholdMs = timeoutMs - warningMs;
-    if (idleMs > warningThresholdMs && !session.timeoutWarningPosted) {
+    const idleWarningWanted = shouldPostLifecycle(ctx.ops.getPlatformOverhead(session.platformId).lifecycle, "idle-warning");
+    if (idleWarningWanted && idleMs > warningThresholdMs && !session.timeoutWarningPosted) {
       const remainingMins = Math.max(0, Math.round((timeoutMs - idleMs) / 60000));
       const warningFormatter = session.platform.getFormatter();
       const warnWaiting = session.isProcessing && (session.messageManager?.hasPendingApproval() === true || session.messageManager?.hasPendingQuestions() === true);
@@ -69846,8 +70047,9 @@ class BasePlatformClient extends EventEmitter3 {
   getBotName() {
     return this.botName;
   }
-  async createInteractivePost(message, reactions, threadId) {
+  async createInteractivePost(message, reactions, threadId, onPostCreated) {
     const post = await this.createPost(message, threadId);
+    onPostCreated?.(post);
     for (const emoji of reactions) {
       try {
         await this.addReaction(post.id, emoji);
@@ -70323,7 +70525,7 @@ class MattermostClient extends BasePlatformClient {
     const post = await this.api("POST", "/posts", request);
     return this.normalizePlatformPost(post);
   }
-  async updatePost(postId, message) {
+  async updatePost(postId, message, _options) {
     const request = {
       id: postId,
       message
@@ -71371,6 +71573,9 @@ class SlackClient extends BasePlatformClient {
     if (resolvedThreadId) {
       body.thread_ts = resolvedThreadId;
     }
+    if (options?.metadata) {
+      body.metadata = options.metadata;
+    }
     const response = await this.api("POST", "chat.postMessage", body);
     return {
       id: response.ts,
@@ -71382,13 +71587,16 @@ class SlackClient extends BasePlatformClient {
       createAt: Math.floor(parseFloat(response.ts) * 1000)
     };
   }
-  async updatePost(postId, message) {
+  async updatePost(postId, message, options) {
     const truncatedMessage = this.truncateMessageIfNeeded(message);
-    const response = await this.api("POST", "chat.update", {
+    const body = {
       channel: this.channelId,
       ts: postId,
       text: truncatedMessage
-    });
+    };
+    if (options?.metadata)
+      body.metadata = options.metadata;
+    const response = await this.api("POST", "chat.update", body);
     return {
       id: response.ts,
       platformId: this.platformId,
@@ -72662,6 +72870,7 @@ function shouldPostResumeRefusal(platformId, threadId, username, now = Date.now(
 // src/session/reaction-router.ts
 init_logger();
 var log52 = createLogger("manager");
+var UNKNOWN_POST_GRACE_MS = 5000;
 async function handleReaction(deps, platformId, postId, emojiName, username, action) {
   const normalizedEmoji = normalizeEmojiName(emojiName);
   if (action === "added" && isResumeEmoji(normalizedEmoji)) {
@@ -72669,9 +72878,13 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
     if (resumed)
       return;
   }
-  const session = deps.registry.findByPost(postId);
-  if (!session)
-    return;
+  let session = deps.registry.findByPost(postId);
+  if (!session) {
+    await deps.registry.awaitPendingPost(postId, UNKNOWN_POST_GRACE_MS);
+    session = deps.registry.findByPost(postId);
+    if (!session)
+      return;
+  }
   if (session.platformId !== platformId)
     return;
   const ownerScoped = resolveApprovals(session.platform.approvals, isDcmThreadId(session.threadId)) === "owner";
@@ -72875,7 +73088,9 @@ class SessionManager extends EventEmitter4 {
     this.platforms.set(platformId, client);
     this.platformOverhead.set(platformId, {
       sessionHeader: options?.overhead?.sessionHeader ?? DEFAULT_OVERHEAD_VISIBILITY,
-      stickyMessage: options?.overhead?.stickyMessage ?? DEFAULT_OVERHEAD_VISIBILITY
+      stickyMessage: options?.overhead?.stickyMessage ?? DEFAULT_OVERHEAD_VISIBILITY,
+      lifecycle: options?.overhead?.lifecycle ?? DEFAULT_OVERHEAD_VISIBILITY,
+      turnMarker: options?.overhead?.turnMarker ?? DEFAULT_TURN_MARKER
     });
     this.platformMemory.set(platformId, options?.memory ?? DEFAULT_MEMORY_CONFIG);
     this.platformRoutines.set(platformId, options?.routinesEnabled ?? true);
@@ -72975,6 +73190,7 @@ class SessionManager extends EventEmitter4 {
       getSessionId: (pid, tid) => this.getSessionId(pid, tid),
       findSessionByThreadId: (tid) => this.findSessionByThreadId(tid),
       registerPost: (pid, tid) => this.registerPost(pid, tid),
+      beginInteractivePost: (tid) => this.registry.beginInteractivePost(tid),
       flush: async (s) => {
         if (s.messageManager) {
           await s.messageManager.flush();
@@ -73012,7 +73228,9 @@ class SessionManager extends EventEmitter4 {
       getClaudeAccountPoolStatus: () => this.accountPool.status(),
       getPlatformOverhead: (pid) => this.platformOverhead.get(pid) ?? {
         sessionHeader: DEFAULT_OVERHEAD_VISIBILITY,
-        stickyMessage: DEFAULT_OVERHEAD_VISIBILITY
+        stickyMessage: DEFAULT_OVERHEAD_VISIBILITY,
+        lifecycle: DEFAULT_OVERHEAD_VISIBILITY,
+        turnMarker: DEFAULT_TURN_MARKER
       },
       getPlatformMemoryConfig: (pid) => this.platformMemory.get(pid) ?? DEFAULT_MEMORY_CONFIG,
       isRoutinesEnabled: (pid) => this.platformRoutines.get(pid) ?? true,
@@ -73305,7 +73523,7 @@ class SessionManager extends EventEmitter4 {
         const pauseMessage = `⏸️ ${fmt.formatBold("Platform disabled")} - session paused. Re-enable platform to resume.`;
         if (session.lifecyclePostId) {
           await session.platform.updatePost(session.lifecyclePostId, pauseMessage);
-        } else {
+        } else if (shouldPostLifecycle(this.platformOverhead.get(session.platformId)?.lifecycle ?? DEFAULT_OVERHEAD_VISIBILITY, "paused")) {
           const post = await session.platform.createPost(pauseMessage, session.threadId);
           session.lifecyclePostId = post.id;
         }
@@ -73797,7 +74015,7 @@ Mention me to start a session in this worktree.`, threadId);
         const shutdownMessage = `⏸️ ${fmt.formatBold("Bot shutting down")} - session will resume on restart`;
         if (session.lifecyclePostId) {
           await session.platform.updatePost(session.lifecyclePostId, shutdownMessage);
-        } else {
+        } else if (shouldPostLifecycle(this.platformOverhead.get(session.platformId)?.lifecycle ?? DEFAULT_OVERHEAD_VISIBILITY, "shutdown")) {
           const post = await session.platform.createPost(shutdownMessage, session.threadId);
           session.lifecyclePostId = post.id;
         }
@@ -86393,10 +86611,11 @@ class UpdateScheduler extends EventEmitter8 {
 }
 
 // src/auto-update/installer.ts
+init_state_home();
 import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync17, readFileSync as readFileSync12, mkdirSync as mkdirSync8 } from "fs";
-import { dirname as dirname9, resolve as resolve7 } from "path";
-import { homedir as homedir10 } from "os";
+import { dirname as dirname9, resolve as resolve8 } from "path";
+import { homedir as homedir3 } from "os";
 init_logger();
 var log56 = createLogger("installer");
 function detectPackageManager() {
@@ -86437,7 +86656,7 @@ function normalizePath(p) {
 function detectOriginalInstaller() {
   try {
     const scriptPath = normalizePath(process.argv[1] || "");
-    const bunGlobalDir = normalizePath(process.env.BUN_INSTALL || resolve7(homedir10(), ".bun"));
+    const bunGlobalDir = normalizePath(process.env.BUN_INSTALL || resolve8(homedir3(), ".bun"));
     if (scriptPath.startsWith(bunGlobalDir)) {
       return "bun";
     }
@@ -86457,7 +86676,7 @@ function detectOriginalInstaller() {
     return null;
   }
 }
-var STATE_PATH = resolve7(homedir10(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
+var STATE_PATH = resolve8(stateHome(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
 var PACKAGE_NAME2 = "claude-threads";
 function loadUpdateState() {
   try {
@@ -86879,6 +87098,102 @@ ${getRollbackInstructions(VERSION)}`).catch(() => {});
     this.callbacks.refreshUI().catch(() => {});
   }
 }
+// src/utils/instance-lock.ts
+init_state_home();
+init_logger();
+import { closeSync as closeSync2, fstatSync, linkSync, mkdirSync as mkdirSync9, openSync as openSync2, readFileSync as readFileSync13, renameSync as renameSync2, statSync as statSync6, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname10, join as join19 } from "path";
+var log59 = createLogger("lock");
+var LOCKED_EXIT_CODE = 3;
+function acquireInstanceLock() {
+  const path = join19(stateHome(), ".config", "claude-threads", "instance.lock");
+  mkdirSync9(dirname10(path), { recursive: true, mode: 448 });
+  const tmp = `${path}.${process.pid}`;
+  writeFileSync6(tmp, String(process.pid), { mode: 384 });
+  try {
+    for (let attempt = 0;attempt < 5; attempt++) {
+      let linked;
+      try {
+        linked = tryLink(tmp, path);
+      } catch (err) {
+        log59.warn(`instance lock unavailable on this filesystem (${err.code ?? String(err)}); running without it`);
+        return () => {};
+      }
+      if (linked)
+        return () => release(path);
+      const seen = inspect(path);
+      if (!seen)
+        continue;
+      if (seen.pid === process.pid)
+        return () => release(path);
+      if (seen.pid && isAlive(seen.pid)) {
+        throw new Error(`another claude-threads instance (pid ${seen.pid}) already uses ${dirname10(path)} — ` + `set CLAUDE_THREADS_HOME to run a second bot; if pid ${seen.pid} is not a claude-threads process, delete ${path}`);
+      }
+      const aside = `${path}.stale.${process.pid}`;
+      if (!tryRename(path, aside))
+        continue;
+      if (statSync6(aside).ino !== seen.ino) {
+        tryLink(aside, path);
+        unlinkSync4(aside);
+        continue;
+      }
+      unlinkSync4(aside);
+    }
+    throw new Error(`could not acquire ${path}: lost the race five times`);
+  } finally {
+    try {
+      unlinkSync4(tmp);
+    } catch {}
+  }
+}
+function inspect(path) {
+  let fd;
+  try {
+    fd = openSync2(path, "r");
+  } catch {
+    return;
+  }
+  try {
+    return { pid: Number(readFileSync13(fd, "utf8").trim()) || undefined, ino: fstatSync(fd).ino };
+  } finally {
+    closeSync2(fd);
+  }
+}
+function tryLink(src, path) {
+  try {
+    linkSync(src, path);
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST")
+      return false;
+    throw err;
+  }
+}
+function tryRename(from, to) {
+  try {
+    renameSync2(from, to);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return false;
+    throw err;
+  }
+}
+function release(path) {
+  try {
+    if (inspect(path)?.pid === process.pid)
+      unlinkSync4(path);
+  } catch {}
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
 // src/index.ts
 function createPlatformClient(config) {
   switch (config.type) {
@@ -87108,6 +87423,15 @@ async function startWithoutDaemon() {
     console.error(yellow(`  ⚠️  --skip-version-check: ${prefix}${claudeValidation.message}`));
     console.error("");
   }
+  let releaseInstanceLock;
+  try {
+    releaseInstanceLock = acquireInstanceLock();
+  } catch (err) {
+    console.error(red(`  ❌ ${err instanceof Error ? err.message : String(err)}`));
+    console.error("");
+    process.exit(LOCKED_EXIT_CODE);
+  }
+  process.on("exit", () => releaseInstanceLock());
   if (process.env.CLAUDE_CODE_SUBPROCESS_ENV_SCRUB === "1") {
     const hasSkipPermissionPlatform = config.platforms.some((p) => p.skipPermissions === true);
     if (hasSkipPermissionPlatform) {
@@ -87286,7 +87610,9 @@ async function startWithoutDaemon() {
     session.addPlatform(platformConfig.id, client, {
       overhead: {
         sessionHeader: resolveOverheadVisibility(platformConfig.sessionHeader, `platforms[${platformConfig.id}].sessionHeader`),
-        stickyMessage: resolveOverheadVisibility(platformConfig.stickyMessage, `platforms[${platformConfig.id}].stickyMessage`)
+        stickyMessage: resolveOverheadVisibility(platformConfig.stickyMessage, `platforms[${platformConfig.id}].stickyMessage`),
+        lifecycle: resolveOverheadVisibility(platformConfig.lifecycle, `platforms[${platformConfig.id}].lifecycle`),
+        turnMarker: resolveTurnMarker(platformConfig.turnMarker, platformConfig.turnMarkerEmoji, platformConfig.type, `platforms[${platformConfig.id}]`)
       },
       memory: resolveMemoryConfig(platformConfig.memory, `platforms[${platformConfig.id}].memory`),
       routinesEnabled: resolveRoutinesEnabled(platformConfig.routines, `platforms[${platformConfig.id}].routines`),
@@ -87313,7 +87639,9 @@ async function startWithoutDaemon() {
       session.addPlatform(dmConfig.id, dmClient, {
         overhead: {
           sessionHeader: resolveOverheadVisibility(dmConfig.sessionHeader, `dm[${dmConfig.id}].sessionHeader`),
-          stickyMessage: "hidden"
+          stickyMessage: "hidden",
+          lifecycle: resolveOverheadVisibility(dmConfig.lifecycle, `dm[${dmConfig.id}].lifecycle`),
+          turnMarker: resolveTurnMarker(dmConfig.turnMarker, dmConfig.turnMarkerEmoji, dmConfig.type, `dm[${dmConfig.id}]`)
         },
         memory: resolveMemoryConfig(dmConfig.memory, `dm[${dmConfig.id}].memory`),
         routinesEnabled: resolveRoutinesEnabled(dmConfig.routines, `dm[${dmConfig.id}].routines`),