claude-threads 1.37.2 → 1.38.0

package/CHANGELOG.md

@@ -5,7 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [1.38.0] - 2026-09-24
+
+### Added
+- **`mode: assistant` names the replies-only shape** (#590, building on #505). A platform entry already carried three fields deciding how much of the bot's scaffolding a channel sees (`sessionHeader`, `stickyMessage`, `lifecycle`), and two deployments described the same combination of all three in nearly the same words. `mode` names it: `full` (default) is the current behaviour, `assistant` hides all three so Claude's reply is the whole thread. A field set explicitly still wins, so `mode: assistant` with `sessionHeader: full` means "replies only, but keep the header". The preset expands when the config loads, so everything downstream reads the same concrete values as before and omitting `mode` behaves identically to today. `turnMarker` stays outside the preset: it is a signal for integrations reading the channel, not something a human sees. Startup warns when a preset is countermanded by an explicit field, because the setup wizard writes `sessionHeader` and `stickyMessage` whenever your answer differed from the default: adding `mode: assistant` to a wizard-made config would otherwise move `lifecycle` alone while looking like it moved everything.
+
+### Fixed
+- **A failed auto-update no longer retries every second forever** (#601). When the first scheduling check already met the restart condition (quiet or scheduled mode with idle sessions, ask mode with no threads), the countdown started before the 10-second check interval existed, so that interval survived and started a second countdown. The first countdown's interval was orphaned: at zero it cleared the new one instead of itself and kept firing "ready" once a second. A successful install exits the process, so this only showed when the install failed, as two posts per second (installing, failed) for as long as the bot ran. The check interval is now armed before the first check, a running countdown is never restarted, and a countdown clears its own interval at zero.
+- **Deferring, cancelling or forcing an update now controls a running countdown** (#601). `!update defer` during the 60-second countdown left the countdown running, so the update installed anyway, and afterwards nothing re-armed the scheduler: a one-hour deferral silently became "until the next release". A deferral now stops the countdown, holds off every trigger (including late ask votes) for the window, and resumes checking when the window ends, asking again in ask mode. `!update now` during a countdown no longer installs a second time when the countdown reaches zero, and cancelling the schedule stops the countdown too.
 
 ## [1.37.2] - 2026-09-18
 

package/dist/index.js

@@ -2232,6 +2232,35 @@ function resolveOverheadVisibility(value, fieldPath) {
     return value;
   throw new Error(`Invalid ${fieldPath}: expected one of ${OVERHEAD_VISIBILITY_VALUES.join(", ")}, got ${JSON.stringify(value)}`);
 }
+function isPresentationMode(value) {
+  return typeof value === "string" && PRESENTATION_MODE_VALUES.includes(value);
+}
+function resolvePresentationMode(value, fieldPath) {
+  if (value === undefined || value === null)
+    return "full";
+  if (isPresentationMode(value))
+    return value;
+  throw new Error(`Invalid ${fieldPath}: expected one of ${PRESENTATION_MODE_VALUES.join(", ")}, got ${JSON.stringify(value)}`);
+}
+function resolvePresentationOverhead(entry, fieldPath) {
+  const preset = PRESENTATION_MODE_EXPANSIONS[resolvePresentationMode(entry.mode, `${fieldPath}.mode`)];
+  const override = (value, field, fallback) => value === undefined || value === null ? fallback : resolveOverheadVisibility(value, `${fieldPath}.${field}`);
+  return {
+    sessionHeader: override(entry.sessionHeader, "sessionHeader", preset.sessionHeader),
+    stickyMessage: override(entry.stickyMessage, "stickyMessage", preset.stickyMessage),
+    lifecycle: override(entry.lifecycle, "lifecycle", preset.lifecycle)
+  };
+}
+function presentationOverridesAgainstPreset(entry) {
+  if (!isPresentationMode(entry.mode) || entry.mode === "full")
+    return [];
+  const preset = PRESENTATION_MODE_EXPANSIONS[entry.mode];
+  const fields = ["sessionHeader", "stickyMessage", "lifecycle"];
+  return fields.filter((field) => {
+    const value = entry[field];
+    return value !== undefined && value !== null && value !== preset[field];
+  });
+}
 function resolveTurnMarker(mode, emoji, platformType, fieldPath) {
   const m = mode === undefined || mode === null ? "off" : mode;
   if (!TURN_MARKER_VALUES.includes(m)) {
@@ -2423,10 +2452,19 @@ function effectivePermissionMode(input) {
     return "default";
   return input.botWideMode;
 }
-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 OVERHEAD_VISIBILITY_VALUES, DEFAULT_OVERHEAD_VISIBILITY = "full", RECONNECT_POLICY_VALUES, DEFAULT_RECONNECT_POLICY = "retry", PRESENTATION_MODE_VALUES, PRESENTATION_MODE_EXPANSIONS, 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"];
+  PRESENTATION_MODE_VALUES = ["full", "assistant"];
+  PRESENTATION_MODE_EXPANSIONS = {
+    full: {
+      sessionHeader: DEFAULT_OVERHEAD_VISIBILITY,
+      stickyMessage: DEFAULT_OVERHEAD_VISIBILITY,
+      lifecycle: DEFAULT_OVERHEAD_VISIBILITY
+    },
+    assistant: { sessionHeader: "hidden", stickyMessage: "hidden", lifecycle: "hidden" }
+  };
   TURN_MARKER_VALUES = ["reaction", "metadata", "off"];
   DEFAULT_TURN_MARKER = { mode: "off" };
   DEFAULT_MEMORY_CONFIG = {
@@ -72234,10 +72272,15 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
   }
   let session = deps.registry.findByPost(postId);
   if (!session) {
+    const hadInFlight = deps.registry.hasInFlightInteractivePost();
     await deps.registry.awaitPendingPost(postId, UNKNOWN_POST_GRACE_MS);
     session = deps.registry.findByPost(postId);
-    if (!session)
+    if (!session) {
+      if (hadInFlight) {
+        log52.debug(`Reaction :${normalizedEmoji}: by @${username} on unknown post ${postId} ` + `dropped after the in-flight grace window (${UNKNOWN_POST_GRACE_MS}ms)`);
+      }
       return;
+    }
   }
   if (session.platformId !== platformId)
     return;
@@ -85754,6 +85797,7 @@ class UpdateScheduler extends EventEmitter8 {
   pendingUpdate = null;
   checkTimer = null;
   countdownTimer = null;
+  deferTimer = null;
   idleStartTime = null;
   scheduledRestartAt = null;
   askApprovals = new Map;
@@ -85776,6 +85820,8 @@ class UpdateScheduler extends EventEmitter8 {
   }
   cancelSchedule() {
     this.stopChecking();
+    this.stopCountdown();
+    this.stopDeferTimer();
     this.pendingUpdate = null;
     this.idleStartTime = null;
     this.scheduledRestartAt = null;
@@ -85784,9 +85830,21 @@ class UpdateScheduler extends EventEmitter8 {
     log55.debug("Update schedule cancelled");
   }
   deferUpdate(minutes) {
-    const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
+    const deferMs = minutes * 60 * 1000;
+    const deferUntil = new Date(Date.now() + deferMs);
+    this.stopCountdown();
+    this.stopChecking();
+    this.stopDeferTimer();
     this.scheduledRestartAt = null;
     this.idleStartTime = null;
+    this.askApprovals.clear();
+    this.askStartTime = null;
+    if (this.pendingUpdate) {
+      this.deferTimer = setTimeout(() => {
+        this.deferTimer = null;
+        this.startChecking();
+      }, deferMs);
+    }
     this.emit("deferred", deferUntil);
     log55.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
     return deferUntil;
@@ -85808,12 +85866,13 @@ class UpdateScheduler extends EventEmitter8 {
   stop() {
     this.stopChecking();
     this.stopCountdown();
+    this.stopDeferTimer();
   }
   startChecking() {
     if (this.checkTimer)
       return;
-    this.checkCondition();
     this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
+    this.checkCondition();
     log55.debug(`Started checking for ${this.config.autoRestartMode} condition`);
   }
   stopChecking() {
@@ -85943,23 +86002,35 @@ class UpdateScheduler extends EventEmitter8 {
     if (!this.pendingUpdate)
       return;
     this.stopChecking();
+    if (this.countdownTimer || this.deferTimer)
+      return;
     this.scheduledRestartAt = new Date(Date.now() + 60000);
     let secondsRemaining = 60;
     this.emit("countdown", secondsRemaining);
-    this.countdownTimer = setInterval(() => {
+    const timer = setInterval(() => {
       secondsRemaining--;
       this.emit("countdown", secondsRemaining);
       if (secondsRemaining <= 0) {
-        this.stopCountdown();
+        clearInterval(timer);
+        if (this.countdownTimer === timer)
+          this.countdownTimer = null;
         this.emit("ready", this.pendingUpdate);
       }
     }, 1000);
+    this.countdownTimer = timer;
     log55.info("Update countdown started (60 seconds)");
   }
   stopCountdown() {
     if (this.countdownTimer) {
       clearInterval(this.countdownTimer);
       this.countdownTimer = null;
+      this.scheduledRestartAt = null;
+    }
+  }
+  stopDeferTimer() {
+    if (this.deferTimer) {
+      clearTimeout(this.deferTimer);
+      this.deferTimer = null;
     }
   }
 }
@@ -86346,6 +86417,7 @@ class AutoUpdateManager extends EventEmitter9 {
       return;
     }
     log58.info("Forcing immediate update");
+    this.scheduler.stop();
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -86731,6 +86803,15 @@ async function startWithoutDaemon() {
   if (cliArgs.keepAlive !== undefined) {
     newConfig.keepAlive = cliArgs.keepAlive;
   }
+  const presetOverrideWarnings = newConfig.platforms.flatMap((platformConfig) => {
+    const overridden = presentationOverridesAgainstPreset(platformConfig);
+    if (overridden.length === 0)
+      return [];
+    const one = overridden.length === 1;
+    return [
+      `  ⚠️  platforms[${platformConfig.id}]: mode: ${String(platformConfig.mode)} is overridden for ${overridden.join(", ")} by ${one ? "an explicit field" : "explicit fields"}. Remove ${one ? "it" : "them"} to let the preset apply.`
+    ];
+  });
   if (cliArgs.sessionHeader !== undefined) {
     for (const p of newConfig.platforms) {
       p.sessionHeader = cliArgs.sessionHeader;
@@ -86745,14 +86826,15 @@ async function startWithoutDaemon() {
   if (!newConfig.platforms || newConfig.platforms.length === 0) {
     throw new Error("No platforms configured. Run with --setup to configure.");
   }
-  let mcpPostureWarnings = [];
+  let startupWarnings = [];
   try {
-    mcpPostureWarnings = resolvePlatformMcpPosture(newConfig.platforms, newConfig.mcpServers).warnings;
+    startupWarnings = resolvePlatformMcpPosture(newConfig.platforms, newConfig.mcpServers).warnings;
   } catch (err) {
     console.error(red(`  ❌ ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
-  for (const w of mcpPostureWarnings)
+  startupWarnings.push(...presetOverrideWarnings);
+  for (const w of startupWarnings)
     console.warn(w);
   const config = newConfig;
   const firstPlatformConfig = config.platforms[0];
@@ -86914,7 +86996,7 @@ async function startWithoutDaemon() {
       }
     }
   });
-  for (const w of mcpPostureWarnings) {
+  for (const w of startupWarnings) {
     ui.addLog({ level: "warn", component: "config", message: w });
   }
   setLogHandler((level, component, message, sessionId) => {
@@ -86963,9 +87045,7 @@ async function startWithoutDaemon() {
     configureAuditLog(platformConfig.id, resolveAuditLogEnabled(platformConfig.auditLog, `platforms[${platformConfig.id}].auditLog`));
     session.addPlatform(platformConfig.id, client, {
       overhead: {
-        sessionHeader: resolveOverheadVisibility(platformConfig.sessionHeader, `platforms[${platformConfig.id}].sessionHeader`),
-        stickyMessage: resolveOverheadVisibility(platformConfig.stickyMessage, `platforms[${platformConfig.id}].stickyMessage`),
-        lifecycle: resolveOverheadVisibility(platformConfig.lifecycle, `platforms[${platformConfig.id}].lifecycle`),
+        ...resolvePresentationOverhead(platformConfig, `platforms[${platformConfig.id}]`),
         turnMarker: resolveTurnMarker(platformConfig.turnMarker, platformConfig.turnMarkerEmoji, platformConfig.type, `platforms[${platformConfig.id}]`)
       },
       memory: resolveMemoryConfig(platformConfig.memory, `platforms[${platformConfig.id}].memory`),
@@ -86992,9 +87072,8 @@ async function startWithoutDaemon() {
       configureAuditLog(dmConfig.id, resolveAuditLogEnabled(dmConfig.auditLog, `dm[${dmConfig.id}].auditLog`));
       session.addPlatform(dmConfig.id, dmClient, {
         overhead: {
-          sessionHeader: resolveOverheadVisibility(dmConfig.sessionHeader, `dm[${dmConfig.id}].sessionHeader`),
+          ...resolvePresentationOverhead(dmConfig, `dm[${dmConfig.id}]`),
           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`),

package/docs/CONFIGURATION.md

@@ -169,6 +169,7 @@ What happens: every `audio/*` attachment (or a file with an audio extension when
 | `permissionMode` | No | How tool-use is gated: `default` / `auto` / `bypass` (default: `default`). See [Permission Modes](#permission-modes). |
 | `skipPermissions` | No | **Deprecated.** Use `permissionMode`. `true` maps to `bypass`, `false` to `default`. `permissionMode` wins when both are set. |
 | `outboundFiles` | No | `send_file` settings: `{ enabled, maxBytes }` (defaults: enabled `true`, `maxBytes` 100 MB) |
+| `mode` | No | Presentation preset: the baseline for `sessionHeader`, `stickyMessage` and `lifecycle`. `full` (default) is the behaviour described below; `assistant` hides all three, so Claude's reply is the whole thread. Any of those three fields set explicitly wins over the preset, so `mode: assistant` with `sessionHeader: full` is valid. `turnMarker` is machine-facing and deliberately not part of the preset. |
 | `sessionHeader` | No | Per-thread header visibility: `full` (default) / `minimal` (status bar only) / `hidden` (no header post) |
 | `stickyMessage` | No | Channel sticky visibility: `full` (default) / `minimal` (status bar only) / `hidden` (no sticky, no bumping) |
 | `lifecycle` | No | Session status posts — idle warning, timeout, pause, resume, and the shutdown notice a deploy leaves in each open thread: `full` (default, all of them) / `minimal` (drops the idle warning, which predicts a timeout the next message would undo anyway) / `hidden` (none). Editing a status post the thread already has is not suppressed at any level: it adds no post and no notification, and leaving a stale "session idle" up across a restart would be worse. ⚠️ An **abnormal exit** (`[Exited: <code>]`, non-zero only) posts at every level including `hidden`: it is a failure report, and silencing it would make a session that died look exactly like one that finished. Note that `hidden` also removes the post a 🔄 reaction resumes from — sending a message in the thread still resumes it, and the channel sticky says so. |
@@ -194,6 +195,7 @@ What happens: every `audio/*` attachment (or a file with an audio extension when
 | `permissionMode` | No | How tool-use is gated: `default` / `auto` / `bypass` (default: `default`). See [Permission Modes](#permission-modes). |
 | `skipPermissions` | No | **Deprecated.** Use `permissionMode`. `true` maps to `bypass`, `false` to `default`. `permissionMode` wins when both are set. |
 | `outboundFiles` | No | `send_file` settings: `{ enabled, maxBytes }` (defaults: enabled `true`, `maxBytes` 100 MB) |
+| `mode` | No | Presentation preset: the baseline for `sessionHeader`, `stickyMessage` and `lifecycle`. `full` (default) is the behaviour described below; `assistant` hides all three, so Claude's reply is the whole thread. Any of those three fields set explicitly wins over the preset, so `mode: assistant` with `sessionHeader: full` is valid. `turnMarker` is machine-facing and deliberately not part of the preset. |
 | `sessionHeader` | No | Per-thread header visibility: `full` (default) / `minimal` (status bar only) / `hidden` (no header post) |
 | `stickyMessage` | No | Channel sticky visibility: `full` (default) / `minimal` (status bar only) / `hidden` (no sticky, no bumping) |
 | `lifecycle` | No | Session status posts — idle warning, timeout, pause, resume, and the shutdown notice a deploy leaves in each open thread: `full` (default, all of them) / `minimal` (drops the idle warning, which predicts a timeout the next message would undo anyway) / `hidden` (none). Editing a status post the thread already has is not suppressed at any level: it adds no post and no notification, and leaving a stale "session idle" up across a restart would be worse. ⚠️ An **abnormal exit** (`[Exited: <code>]`, non-zero only) posts at every level including `hidden`: it is a failure report, and silencing it would make a session that died look exactly like one that finished. Note that `hidden` also removes the post a 🔄 reaction resumes from — sending a message in the thread still resumes it, and the channel sticky says so. |
@@ -203,6 +205,56 @@ What happens: every `audio/*` attachment (or a file with an audio extension when
 | `reconnectPolicy` | No | What happens when reconnection attempts run out: `retry` (default — log, cool down 60s, reset the counter and keep trying; recovers with no supervisor) or `exit` (leave through the graceful shutdown path and exit non-zero, for `Restart=always` deployments). The bot never stays alive with a dead socket either way. |
 | `auditLog` | No | Append-only audit trail of what the bot executed for this platform — tool calls (incl. subagents), session lifecycle, security-relevant commands, plan approvals. One JSONL stream per platform under `~/.claude-threads/audit/` (override: `CLAUDE_THREADS_AUDIT_DIR`), files `0600`. The bot never deletes it — rotation/retention is the operator's job (logrotate, SIEM ingestion). See [Audit log](#audit-log). Default off. |
 
+### Presentation presets (`mode`)
+
+A platform entry carries three fields that decide how much of the bot's own
+scaffolding a channel sees: `sessionHeader`, `stickyMessage` and `lifecycle`.
+They are useful separately, but almost nobody wants to tune them one by one.
+Two deployments asked for the same combination in nearly the same words: the
+reply, and nothing else.
+
+`mode` names that combination.
+
+```yaml
+platforms:
+  - id: assistant-channel
+    type: slack
+    mode: assistant      # no header, no sticky, no lifecycle notices
+```
+
+| Preset | `sessionHeader` | `stickyMessage` | `lifecycle` |
+|--------|-----------------|-----------------|-------------|
+| `full` (default) | `full` | `full` | `full` |
+| `assistant` | `hidden` | `hidden` | `hidden` |
+
+A field set explicitly always wins over the preset, so you can start from a
+preset and keep one thing:
+
+```yaml
+    mode: assistant
+    sessionHeader: full   # replies only, but keep the per-thread header
+```
+
+One caveat worth knowing if you ran the setup wizard. It writes `sessionHeader`
+and `stickyMessage` into your config whenever your answer differed from the
+default, and those are explicit fields, so they win. Adding `mode: assistant`
+to such a config moves `lifecycle` and leaves the other two where the wizard
+put them. Startup warns and names the fields when that happens; remove them to
+let the preset apply.
+
+Two more things worth knowing:
+
+- The preset is expanded when the config loads, so everything downstream reads
+  the same three concrete values it always did. Omitting `mode` resolves to
+  exactly the old defaults, which means an existing config behaves identically.
+- `turnMarker` is **not** part of any preset. It is a signal for integrations
+  reading the channel rather than something a human sees, so it is not
+  something you would switch off because you want a quieter channel.
+
+An abnormal exit is still reported under `mode: assistant`, for the reason
+given in the `lifecycle` row above: a session that died must not look like one
+that finished.
+
 ### Direct Channel Mode
 
 `directChannelMode: true` turns the configured channel into a single, always-on conversation with the bot:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.37.2",
+  "version": "1.38.0",
   "description": "Run Claude Code from Slack or Mattermost. Sessions stream live into threads where your whole team can watch and steer.",
   "main": "dist/index.js",
   "type": "module",