tokenmaxxing 0.19.0 → 0.19.1

package/DESIGN.md

@@ -92,7 +92,9 @@ A local Socket Mode daemon (no public URL) that turns Slack threads into Claude
 - **Turn = spawn**: each thread message runs ONE `query()` with `resume: sessionId` (never a persistent streaming query - the SDK subprocess reads credentials at spawn, so per-turn spawns are what let `ensureBestAccount()` land each turn on the freshest account, and the daemon can restart without losing threads). `stopHookCheck` rides along as the SDK Stop hook. Streamed `text_delta`s feed `thread.post(AsyncIterable)` (the adapter debounces edits); tool-only turns post the final result text.
 - **Safety posture**: per-link `permissionMode`, default `acceptEdits`; `--yolo` (alias `--dangerous`) opts a link into `bypassPermissions`, and relayThread pairs it with the SDK's mandatory `allowDangerouslySkipPermissions: true` opt-in. `AskUserQuestion` is disallowed (unanswerable over Slack; the model asks in prose instead). Turn failures post a trimmed message-only diagnostic (never a raw error body).
 - **Socket lifecycle**: `bot.initialize()` starts the persistent auto-reconnecting SocketModeClient; the daemon then just stays alive. The leased `startSocketModeListener` API must never be looped: it returns instantly without `waitUntil` and the loop starves the event loop (live incident 2026-07-18 - connected but silent).
-- **Id mapping**: Chat SDK ids are adapter-prefixed (`thread.channelId` = `slack:C0123`, `thread.id` = `slack:C0123:<threadTs>`) while links store bare Slack ids - lookups strip the prefix via `bareChannelId`. Subscriptions live in the daemon's memory state, so every mention re-subscribes its thread (a restarted daemon revives an old thread on the next mention); queue-skipped messages (`context.skipped`) fold into the next prompt, with the queue-entry TTL raised to 900s; unlinked-channel traffic logs `serve.unlinked_channel` and stays silent in Slack.
+- **Id mapping**: Chat SDK ids are adapter-prefixed (`thread.channelId` = `slack:C0123`, `thread.id` = `slack:C0123:<threadTs>`) while links store bare Slack ids - lookups strip the prefix via `bareChannelId`. Subscriptions live in the daemon's memory state, so every mention re-subscribes its thread; queue-skipped messages (`context.skipped`) fold into the next prompt, with the queue-entry TTL raised to 900s; unlinked-channel traffic logs `serve.unlinked_channel` and stays silent in Slack.
+- **Restart resilience** (0.19.0, from the 2026-07-18 dead-thread incident: a deploy restart cut a turn mid-answer and left the thread deaf to follow-ups): startup re-subscribes every `slack-threads/` record straight on the state adapter (`state.subscribe(threadId)`; message routing checks `stateAdapter.isSubscribed`, verified in chat 4.34.0), so open threads survive restarts without needing a fresh mention. SIGTERM/SIGINT drains instead of dying: new turns are dropped loudly (`serve.drain_dropped`), tracked in-flight turns get up to 300s to finish, then `Chat.shutdown()`; a second signal forces exit. When a `thread.post` rejects mid-turn (e.g. Slack finalizes an idle stream: `message_not_in_streaming_state`), relayThread drops the dead segment so the rest of the turn opens fresh messages instead of vanishing.
+- **Slack-native output hygiene**: relayed turns run a small standalone `systemPrompt` telling the model replies render as Slack markdown, never HTML (a live turn once answered with a literal `<br>`; the SDK's default system prompt is minimal since 0.1.0, so the string replaces nothing), and whitespace-only text deltas do not count as reply text for segment breaking (no stranded near-blank messages).
 - **Agent representation** (`src/lib/slackstream.ts`): turns stream natively (`chat.startStream`, which works in channel threads regardless of the assistant:write scope): thinking and tool calls as task cards ("Thinking"/tool name/"Turn", input summary + truncated output), reply text as native markdown with rendered code fences, and a segment break whenever a tool starts after streamed text, so one turn posts as separate ordered Slack messages around its tool runs.
 - **Live-verified end-to-end** (2026-07-18, #tokenmaxxing-dogfooding): mention opens worktree + session, replies stream, thread follow-ups resume with context, cards + fenced code render, segmentation and queue folding behave. Plus the hermetic suite: schemas/links, worktree idempotency, stream mapping, fail-fast paths.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/serve.ts

@@ -14,6 +14,7 @@
 //   serve                  run the daemon
 
 import { existsSync, realpathSync } from "node:fs";
+import { delay } from "es-toolkit";
 import { Chat, type StreamChunk } from "chat";
 import { createSlackAdapter } from "@chat-adapter/slack";
 import { createMemoryState } from "@chat-adapter/state-memory";
@@ -21,6 +22,7 @@ import {
   bareChannelId,
   isChannelId,
   linkForChannel,
+  listSlackThreads,
   loadSlackConfig,
   loadSlackThread,
   removeLink,
@@ -211,10 +213,14 @@ async function runDaemon(): Promise<number> {
     // so the values are inlined).
     webClientOptions: { retryConfig: { retries: 5, factor: 3.86 }, timeout: 15_000 },
   });
+  // held directly (not only via Chat) so startup can re-subscribe recorded
+  // threads: subscriptions live in this in-memory state and die with the
+  // process, and only a fresh mention would otherwise revive a thread.
+  const state = createMemoryState();
   const bot = new Chat({
     userName: "tokenmaxxing",
     adapters: { slack },
-    state: createMemoryState(),
+    state,
     // per-thread lock with queueing: a message landing mid-turn waits its turn
     // instead of racing a second claude spawn on the same cwd. The default
     // 90s queue-entry TTL silently discards anything queued behind a turn
@@ -226,12 +232,25 @@ async function runDaemon(): Promise<number> {
     logger: "warn",
   });
 
+  // in-flight turns, tracked so a shutdown signal can drain them instead of
+  // killing a half-streamed answer (live incident 2026-07-18: a deploy
+  // restart cut a turn mid-sentence and the answer never reached Slack).
+  const activeTurns = new Set<Promise<void>>();
+  let draining = false;
+
   const handleTurn = async (input: {
     thread: { id: string; channelId: string; post: (m: AsyncIterable<string | StreamChunk>) => Promise<unknown>; subscribe: () => Promise<void>; startTyping: () => Promise<void> };
     texts: string[];
     isMention: boolean;
   }) => {
     const { thread, texts, isMention } = input;
+    if (draining) {
+      // the socket stays connected until the drain finishes; anything landing
+      // in that window is dropped loudly rather than spawning an unwaitable
+      // turn. The user re-sends after the restart.
+      log("serve.drain_dropped", { thread: thread.id });
+      return;
+    }
     const link = linkForChannel(cfg, bareChannelId(thread.channelId));
     if (!link) {
       log("serve.unlinked_channel", { channel: thread.channelId });
@@ -274,14 +293,23 @@ async function runDaemon(): Promise<number> {
 
   const relayable = (m: { author: { isMe: boolean; isBot?: boolean | "unknown" } }) => !m.author.isMe && m.author.isBot !== true;
 
+  const tracked = async (turn: Promise<void>) => {
+    activeTurns.add(turn);
+    try {
+      await turn;
+    } finally {
+      activeTurns.delete(turn);
+    }
+  };
+
   bot.onNewMention(async (thread, message, context) => {
     const texts = [...(context?.skipped ?? []).filter(relayable), message].map((m) => m.text);
-    await handleTurn({ thread, texts, isMention: true });
+    await tracked(handleTurn({ thread, texts, isMention: true }));
   });
   bot.onSubscribedMessage(async (thread, message, context) => {
     if (!relayable(message)) return; // never relay our own posts
     const texts = [...(context?.skipped ?? []).filter(relayable), message].map((m) => m.text);
-    await handleTurn({ thread, texts, isMention: false });
+    await tracked(handleTurn({ thread, texts, isMention: false }));
   });
 
   // initialize() starts the PERSISTENT Socket Mode client (auto-reconnecting)
@@ -291,6 +319,36 @@ async function runDaemon(): Promise<number> {
   // and awaiting it in a loop starved the event loop so hard the WebSocket
   // never delivered a single event (live incident 2026-07-18).
   await bot.initialize();
+
+  // subscriptions live in the memory state and died with the previous daemon;
+  // the durable slack-threads/ records say which threads are ours, so restore
+  // routing for them (message routing checks stateAdapter.isSubscribed,
+  // verified in chat 4.34.0). Without this a restart leaves every open thread
+  // deaf to non-mention follow-ups.
+  const records = listSlackThreads();
+  for (const record of records) await state.subscribe(record.threadId);
+  log("serve.resubscribed", { threads: records.length });
+
+  // drain instead of dying mid-answer: stop taking new turns, let in-flight
+  // ones finish (bounded - a hung claude turn must not block a restart
+  // forever), then disconnect. A second signal forces an immediate exit.
+  const DRAIN_MS = 300_000;
+  const shutdown = async (signal: string) => {
+    if (draining) {
+      log("serve.forced_exit", { signal });
+      process.exit(1);
+    }
+    draining = true;
+    log("serve.draining", { signal, turns: activeTurns.size });
+    console.log(`${c.yellow("●")} ${signal}: draining ${count({ n: activeTurns.size, noun: "in-flight turn" })} (again to force)`);
+    await Promise.race([Promise.allSettled([...activeTurns]), delay(DRAIN_MS)]);
+    await bot.shutdown();
+    log("serve.stopped", { dropped: activeTurns.size });
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+
   console.log(`${c.green("●")} serving ${count({ n: cfg.links.length, noun: "linked channel" })} over Slack Socket Mode - mention the bot in a linked channel to open a session (Ctrl-C to stop)`);
   log("serve.started", { links: cfg.links.length });
   await new Promise<never>(() => {});

package/src/lib/slackbridge.ts

@@ -16,6 +16,14 @@ import { threadKey, type SlackLink } from "./slackstate.ts";
 import { agentEventChunks, newStreamMapState, SegmentBreakSchema } from "./slackstream.ts";
 import { log } from "./log.ts";
 
+/** With systemPrompt omitted the SDK runs a MINIMAL system prompt (the
+ *  claude_code preset is opt-in since SDK 0.1.0, re-verified for 0.3.214
+ *  2026-07-18), so this small standalone prompt replaces nothing. It exists
+ *  because a relayed model once answered with a literal "<br>": Slack renders
+ *  markdown, never HTML. */
+const SLACK_SYSTEM_PROMPT =
+  "Your replies are relayed into a Slack thread and render as Slack-flavored markdown. Write plain markdown only - never HTML tags such as <br> (use real line breaks).";
+
 export const TurnOutcomeSchema = z.object({
   sessionId: z.string().nullable(),
   failed: z.boolean(),
@@ -118,9 +126,14 @@ export async function relayThread(input: {
       await lastPost; // strict message order: previous segment fully posted first
       seg = pushableStream();
       segment = seg;
+      const posted = seg;
       lastPost = input.post(seg.iterable).catch((e: unknown) => {
         const detail = (e instanceof Error ? e.message : String(e)).slice(0, 300);
         log("serve.post_error", { err: detail });
+        // the consumer is gone (e.g. Slack finalized an idle stream:
+        // message_not_in_streaming_state) - drop the dead segment so the
+        // next chunk opens a fresh message instead of vanishing into it.
+        if (segment === posted) segment = null;
       });
     }
     if (!postedText && !(chunk instanceof Object)) postedText = true;
@@ -142,6 +155,7 @@ export async function relayThread(input: {
         // the SDK refuses bypassPermissions without this explicit opt-in.
         ...(input.link.permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
         includePartialMessages: true,
+        systemPrompt: SLACK_SYSTEM_PROMPT,
         // no one can answer an interactive question dialog through Slack;
         // without the tool the model asks in prose and the user's thread
         // reply becomes the next turn.

package/src/lib/slackstream.ts

@@ -133,7 +133,10 @@ export function agentEventChunks(input: { state: StreamMapState; message: SDKMes
       const open = state.open[`${message.parent_tool_use_id ?? "main"}:${event.index}`];
       if (event.delta.type === "text_delta") {
         if (!isMain) return [];
-        state.textSinceBreak = true;
+        // whitespace-only deltas must not count as reply text: a "\n\n"
+        // before a tool call would otherwise break the segment and strand a
+        // near-blank Slack message.
+        if (event.delta.text.trim() !== "") state.textSinceBreak = true;
         return [event.delta.text];
       }
       if (event.delta.type === "thinking_delta" && open) open.acc += event.delta.thinking;