tokenmaxxing 0.18.0 → 0.19.1

package/DESIGN.md

@@ -90,8 +90,13 @@ A local Socket Mode daemon (no public URL) that turns Slack threads into Claude
 - **Config**: `slack.json` (0600 - it holds the xoxb-/xapp- tokens) with per-channel links `{channel, repo, worktree, permissionMode, model?}`. `serve setup` prints the app manifest (minimal scopes: app_mentions:read, channels:history, groups:history, chat:write, files:write, users:read + socket mode) and prompts for the tokens; `serve link <channel-id> <repo>` manages links (channel IDs only - names drift, ids don't).
 - **Thread = session**: a bot mention in a linked channel subscribes the thread, creates `slack-worktrees/<threadKey>` (branch `tm-slack-<threadKey>` cut from the repo's HEAD; `--no-worktree` links run in the repo itself), and records `{threadId, cwd, sessionId}` under `slack-threads/`. Resume is cwd-keyed in claude, so the cwd stays byte-stable for the thread's life; worktrees are never auto-deleted (they hold the thread's work).
 - **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`; `--dangerous` opts a link into `bypassPermissions`. Turn failures post a trimmed message-only diagnostic (never a raw error body). The socket loop aborts visibly after 3 consecutive connection failures.
-- **Verified hermetically** (2026-07-18): schema/link management, worktree creation + idempotency, arg parsing, daemon fail-fast paths. **Not yet live-verified**: a real Socket Mode connection under Bun (needs real tokens; the underlying ws/undici primitives tested clean) and a real relayed turn (meters an account). Run one live smoke test before relying on it.
+- **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; 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.
 
 ---
 
@@ -124,7 +129,7 @@ A local Socket Mode daemon (no public URL) that turns Slack threads into Claude
 ---
 
 ## 8. Stack
-TypeScript on Bun, shipped as source: one multi-call entry (`src/main.ts`, `#!/usr/bin/env bun`) serves the CLI, the `claude` supervisor, the statusLine shim, and the hooks; `init` installs a 2-line shim that `exec`s bun on the installed package's entry (the Stop path runs every turn; bun's start-up stays low-millisecond). Published to npm as `tokenmaxxing` (source, platform-independent - a compiled binary was tried and shipped one architecture's Mach-O to every platform). The supervisor needs a real PTY layer (spawn claude on a pty, forward resize/signals, restore mode between runs).
+TypeScript on Bun, shipped as source: one multi-call entry (`src/main.ts`, `#!/usr/bin/env bun`) serves the CLI, the `claude` supervisor, the statusLine shim, and the hooks; `init` installs a 2-line shim that `exec`s bun on the installed package's entry (the Stop path runs every turn; bun's start-up stays low-millisecond). Published to npm as `tokenmaxxing` (source, platform-independent - a compiled binary was tried and shipped one architecture's Mach-O to every platform). Shipping is PR-based since 2026-07-18: work reaches main only through a pull request (branch, PR, CI green, review handled, merge), and a release is a PR-landed version bump followed by `gh release create` (details in AGENTS.md "Release and CI"). The supervisor needs a real PTY layer (spawn claude on a pty, forward resize/signals, restore mode between runs).
 
 ---
 

package/README.md

@@ -45,7 +45,7 @@ claude                  # use claude as always
 | `tokenmaxxing status --force` | additionally ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh |
 | `tokenmaxxing watch [seconds]` | live status: re-render every N seconds (default 120, floor 30; never pings) |
 | `tokenmaxxing config` | effective config with sources; `get`/`set`/`unset` dotted keys, `tidy` prunes unknown keys |
-| `tokenmaxxing serve` | Slack bridge daemon (Socket Mode, no public URL): `setup` prints the app manifest and stores the two tokens, `link <channel-id> <repo>` ties a channel to a repo, then mentioning the bot in that channel opens a Claude Code session per thread (own git worktree by default) and thread messages relay in and out |
+| `tokenmaxxing serve` | Slack bridge daemon (Socket Mode, no public URL): `setup` prints the app manifest and stores the two tokens, `link <channel-id> <repo>` ties a channel to a repo (`--yolo` for full-autonomy bypassPermissions sessions), then mentioning the bot in that channel opens a Claude Code session per thread (own git worktree by default) and thread messages relay in and out |
 | `tokenmaxxing doctor` | verify the supervisor + settings entries survived |
 | `tokenmaxxing rename [--codex] <sel> <label>` / `rm <sel>` | manage the pool (`--codex` targets the codex pool: one email can hold both a claude and a codex account) |
 | `tokenmaxxing uninstall` | remove supervisor + settings entries (accounts/credentials kept) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "0.18.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,12 +14,15 @@
 //   serve                  run the daemon
 
 import { existsSync, realpathSync } from "node:fs";
-import { Chat } from "chat";
+import { delay } from "es-toolkit";
+import { Chat, type StreamChunk } from "chat";
 import { createSlackAdapter } from "@chat-adapter/slack";
 import { createMemoryState } from "@chat-adapter/state-memory";
 import {
+  bareChannelId,
   isChannelId,
   linkForChannel,
+  listSlackThreads,
   loadSlackConfig,
   loadSlackThread,
   removeLink,
@@ -30,20 +33,24 @@ import {
   SlackLinkSchema,
   type SlackConfig,
 } from "../lib/slackstate.ts";
-import { ensureThreadCwd, relayTurn, type TurnOutcome } from "../lib/slackbridge.ts";
+import { ensureThreadCwd, relayThread } from "../lib/slackbridge.ts";
 import { log } from "../lib/log.ts";
 import { c, count } from "./render.ts";
 
-const SERVE_USAGE = "usage: tokenmaxxing serve [setup | link <channel-id> <repo> [--no-worktree] [--dangerous] [--model <m>] | unlink <channel-id> | links]";
+const SERVE_USAGE = "usage: tokenmaxxing serve [setup | link <channel-id> <repo> [--no-worktree] [--yolo | --dangerous] [--model <m>] | unlink <channel-id> | links]";
 
 /** The manifest the user pastes at api.slack.com/apps > From an app manifest.
- *  Scopes/events verified against docs.slack.dev 2026-07-18: exactly what a
- *  channel-thread relay needs, nothing more. */
+ *  Scopes/events verified against docs.slack.dev 2026-07-18: a channel-thread
+ *  relay plus Slack's Agent messaging experience (agent_view + assistant:write
+ *  power the DM assistant surface and typing status; channel-thread streaming
+ *  works without them, verified live). Changing scopes on an existing app
+ *  requires reinstalling it to the workspace. */
 const APP_MANIFEST = `display_information:
   name: tokenmaxxing
   description: bridges Slack threads to Claude Code sessions
 
 features:
+  agent_view: true
   bot_user:
     display_name: tokenmaxxing
     always_online: true
@@ -52,6 +59,7 @@ oauth_config:
   scopes:
     bot:
       - app_mentions:read
+      - assistant:write
       - channels:history
       - groups:history
       - chat:write
@@ -61,9 +69,12 @@ oauth_config:
 settings:
   event_subscriptions:
     bot_events:
+      - app_context_changed
+      - app_home_opened
       - app_mention
       - message.channels
       - message.groups
+      - message.im
   socket_mode_enabled: true
   org_deploy_enabled: false
   token_rotation_enabled: false`;
@@ -77,6 +88,7 @@ function printSetupInstructions(): void {
   console.log("2. OAuth & Permissions > Install to Workspace, copy the Bot User OAuth Token (xoxb-...).");
   console.log("3. Basic Information > App-Level Tokens > Generate (add the connections:write scope), copy the token (xapp-...).");
   console.log(`4. Run ${c.cyan("tokenmaxxing serve setup")} and paste both tokens, then ${c.cyan("tokenmaxxing serve link <channel-id> <repo>")} and invite the bot to that channel.`);
+  console.log(`${c.dim("Existing app? Paste the manifest over App Manifest in its settings, then reinstall to the workspace (scope changes need it). Tokens stay valid unless you rotate them.")}`);
 }
 
 function cmdServeSetup(): number {
@@ -103,7 +115,8 @@ function cmdServeSetup(): number {
 
 function cmdServeLink(argv: string[]): number {
   const worktree = !argv.includes("--no-worktree");
-  const dangerous = argv.includes("--dangerous");
+  // yolo mode = the SDK's bypassPermissions; --dangerous is the same switch.
+  const dangerous = argv.includes("--yolo") || argv.includes("--dangerous");
   const modelIdx = argv.indexOf("--model");
   const model = modelIdx >= 0 ? argv[modelIdx + 1] : undefined;
   const rest = argv.filter((a, i) => !a.startsWith("--") && (modelIdx < 0 || i !== modelIdx + 1));
@@ -172,12 +185,6 @@ function cmdServeLinks(): number {
   return 0;
 }
 
-/** One socket lease: how long each startSocketModeListener call holds the
- *  WebSocket before the loop reconnects (the adapter treats the listener as
- *  leased, not infinite). */
-const SOCKET_LEASE_MS = 3_600_000;
-const MAX_CONSECUTIVE_FAILURES = 3;
-
 async function runDaemon(): Promise<number> {
   const cfg = loadSlackConfig();
   if (!cfg) {
@@ -189,66 +196,163 @@ async function runDaemon(): Promise<number> {
     return 1;
   }
 
-  const slack = createSlackAdapter({ mode: "socket", botToken: cfg.botToken, appToken: cfg.appToken });
+  const slack = createSlackAdapter({
+    mode: "socket",
+    botToken: cfg.botToken,
+    appToken: cfg.appToken,
+    // Native append-streaming (chat.startStream) with task cards is the
+    // correct mode (user-confirmed live 2026-07-18): it works in channel
+    // threads even when auth.test reports no assistant:write, so never gate
+    // it on a scope probe. The adapter falls back to post-and-edit by itself
+    // when a workspace truly rejects streaming. agentView matches the
+    // manifest's Agent messaging experience for the DM surface.
+    agentView: true,
+    // the web-api default retry policy (tenRetriesInAboutThirtyMinutes) can
+    // stall a streamed turn ~30min on one rate-limited edit; this is
+    // @slack/web-api's fiveRetriesInFiveMinutes literal (dep not declared,
+    // 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 being dropped or racing a second claude spawn on the same cwd.
-    concurrency: "queue",
+    // instead of racing a second claude spawn on the same cwd. The default
+    // 90s queue-entry TTL silently discards anything queued behind a turn
+    // longer than that (claude turns routinely are), hence the override.
+    concurrency: { strategy: "queue", queueEntryTtlMs: 900_000 },
+    // without this a cards-only segment in post-and-edit fallback would
+    // strand a bare "..." placeholder message.
+    fallbackStreamingPlaceholderText: null,
     logger: "warn",
   });
 
-  const handleTurn = async (thread: { id: string; channelId: string; post: (m: AsyncIterable<string>) => Promise<unknown>; subscribe: () => Promise<void> }, rawText: string, isMention: boolean) => {
-    const link = linkForChannel(cfg, thread.channelId);
-    if (!link) return; // not a linked channel - stay silent
-    const prompt = stripLeadingMention(rawText);
+  // 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 });
+      return; // not a linked channel - stay silent in Slack
+    }
+    log("serve.message", { thread: thread.id, isMention, texts: texts.length });
+    // texts carries queue-skipped messages plus the triggering one: the queue
+    // strategy hands a turn only the LATEST message and the rest via
+    // context.skipped, so they are folded into one prompt here.
+    const prompt = texts
+      .map((t) => stripLeadingMention(t))
+      .filter((t) => t !== "")
+      .join("\n\n");
     if (!prompt) return;
     let record = loadSlackThread(thread.id);
     if (!record) {
       if (!isMention) return; // only a mention opens a session
-      await thread.subscribe();
       const cwd = ensureThreadCwd({ link, threadId: thread.id });
       record = { threadId: thread.id, repo: link.repo, cwd, sessionId: null, createdAt: new Date().toISOString() };
       saveSlackThread(record);
       log("serve.thread_opened", { thread: thread.id, cwd });
     }
-    const outcome: TurnOutcome = { sessionId: record.sessionId, failed: false };
-    await thread.post(relayTurn({ cwd: record.cwd, sessionId: record.sessionId, prompt, link }, outcome));
+    // subscriptions live in the memory state, so a daemon restart forgets
+    // them; every mention re-subscribes to keep follow-up replies flowing.
+    if (isMention) await thread.subscribe();
+    // "is working..." assistant status; a no-op until the Slack app has the
+    // agent feature + assistant:write (the adapter warns instead of throwing).
+    await thread.startTyping();
+    const outcome = await relayThread({
+      cwd: record.cwd,
+      sessionId: record.sessionId,
+      prompt,
+      link,
+      post: (m) => thread.post(m),
+    });
     if (outcome.sessionId !== record.sessionId) {
       saveSlackThread({ ...record, sessionId: outcome.sessionId });
     }
   };
 
-  bot.onNewMention(async (thread, message) => {
-    await handleTurn(thread, message.text, true);
+  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 tracked(handleTurn({ thread, texts, isMention: true }));
   });
-  bot.onSubscribedMessage(async (thread, message) => {
-    if (message.author.isMe || message.author.isBot === true) return; // never relay our own posts
-    await handleTurn(thread, message.text, false);
+  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 tracked(handleTurn({ thread, texts, isMention: false }));
   });
 
+  // initialize() starts the PERSISTENT Socket Mode client (auto-reconnecting)
+  // wired straight into event routing; the daemon only has to stay alive.
+  // Never call startSocketModeListener here: that is the serverless leased
+  // variant (it demands options.waitUntil and returns instantly without it),
+  // 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();
-  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`);
 
-  let consecutiveFailures = 0;
-  while (true) {
-    try {
-      await slack.startSocketModeListener({}, SOCKET_LEASE_MS);
-      consecutiveFailures = 0;
-    } catch (e) {
-      consecutiveFailures += 1;
-      const err = (e instanceof Error ? e.message : String(e)).slice(0, 200);
-      console.error(c.red(`socket listener failed (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${err}`));
-      log("serve.socket_error", { err, consecutiveFailures });
-      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-        console.error(c.red("giving up after 3 consecutive socket failures - check the tokens with `tokenmaxxing serve setup`"));
-        return 1;
-      }
-      await Bun.sleep(5_000);
+  // 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>(() => {});
+  return 0;
 }
 
 export async function cmdServe(argv: string[]): Promise<number> {

package/src/lib/decide.ts

@@ -111,7 +111,7 @@ function usageFresh(u: UsageState | null, org: string | null, ttl: number, now:
  * are absent, org-drifted, or older than the poll TTL. ONE probe carries all
  * three limit kinds, so a success refreshes BOTH files; anything less leaves a
  * headless box (no rendering statusLine to tee) evaluating frozen or
- * org-mismatched values forever - the 2026-07-12 stella blindness. The
+ * org-mismatched values forever - the 2026-07-12 ARM-box blindness. The
  * refreshed usage carries model: null (whatever session stamped the old model
  * may be gone), which gates every configured family. model-usage.json's ts also
  * stamps FAILED attempts, so a busy live token cannot cause a probe storm

package/src/lib/slackbridge.ts

@@ -9,19 +9,64 @@ import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import type { StreamChunk } from "chat";
 import { ensureBestAccount, pooledOptions, stopHookCheck } from "../sdk.ts";
 import { paths } from "./paths.ts";
 import { threadKey, type SlackLink } from "./slackstate.ts";
+import { agentEventChunks, newStreamMapState, SegmentBreakSchema } from "./slackstream.ts";
 import { log } from "./log.ts";
 
-/** Mutated in place by relayTurn so the caller can hand the generator straight
- *  to thread.post(AsyncIterable) and still read the turn's outcome afterward. */
+/** 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(),
 });
 export type TurnOutcome = z.infer<typeof TurnOutcomeSchema>;
 
+const SegmentChunkSchema = z.union([z.string(), z.custom<StreamChunk>()]);
+type SegmentChunk = z.infer<typeof SegmentChunkSchema>;
+
+/** A hand-pushed async iterable: relayThread feeds one of these per Slack
+ *  message segment while thread.post concurrently drains it. */
+function pushableStream(): {
+  iterable: AsyncIterable<SegmentChunk>;
+  push: (chunk: SegmentChunk) => void;
+  end: () => void;
+} {
+  const queue: SegmentChunk[] = [];
+  let done = false;
+  let notify: (() => void) | null = null;
+  return {
+    push(chunk) {
+      queue.push(chunk);
+      notify?.();
+    },
+    end() {
+      done = true;
+      notify?.();
+    },
+    iterable: {
+      async *[Symbol.asyncIterator]() {
+        while (true) {
+          for (let next = queue.shift(); next !== undefined; next = queue.shift()) yield next;
+          if (done) return;
+          await new Promise<void>((resolve) => {
+            notify = resolve;
+          });
+          notify = null;
+        }
+      },
+    },
+  };
+}
+
 /** Run one git command against a repo; throws with trimmed stderr on failure. */
 function git(repo: string, args: string[]): string {
   const r = Bun.spawnSync(["git", "-C", repo, ...args], { stdout: "pipe", stderr: "pipe" });
@@ -54,16 +99,50 @@ export function ensureThreadCwd(input: { link: SlackLink; threadId: string }): s
 }
 
 /**
- * One claude turn, yielded as streaming text deltas (feed directly to
- * thread.post). Never throws: a failure yields a short diagnostic line and
+ * One claude turn relayed into a Slack thread as a SEQUENCE of messages: reply
+ * text streams natively, thinking and tool calls stream as task_update cards
+ * (see slackstream.ts), and a segment_break (a tool starting after streamed
+ * text) closes the current Slack message and opens the next one, so a turn
+ * reads as separate messages around its tool runs (user ask 2026-07-18).
+ * Segments post strictly in order: the next opens only after the previous
+ * post resolves. Never throws: a failure posts a short diagnostic line and
  * sets outcome.failed (the daemon must keep serving other threads). Error
  * text is message-only - a raw error body could echo request material.
  */
-export async function* relayTurn(
-  input: { cwd: string; sessionId: string | null; prompt: string; link: SlackLink },
-  outcome: TurnOutcome,
-): AsyncGenerator<string> {
-  let yieldedAny = false;
+export async function relayThread(input: {
+  cwd: string;
+  sessionId: string | null;
+  prompt: string;
+  link: SlackLink;
+  post: (m: AsyncIterable<SegmentChunk>) => Promise<unknown>;
+}): Promise<TurnOutcome> {
+  const outcome: TurnOutcome = { sessionId: input.sessionId, failed: false };
+  let segment: ReturnType<typeof pushableStream> | null = null;
+  let lastPost: Promise<unknown> = Promise.resolve();
+  let postedText = false;
+  const push = async (chunk: SegmentChunk) => {
+    let seg = segment;
+    if (!seg) {
+      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;
+    seg.push(chunk);
+  };
+  const breakSegment = () => {
+    segment?.end();
+    segment = null;
+  };
   try {
     // the switch decision runs at the spawn boundary, same as the CLI hooks.
     await ensureBestAccount();
@@ -73,35 +152,43 @@ export async function* relayTurn(
         ...pooledOptions(),
         cwd: input.cwd,
         permissionMode: input.link.permissionMode,
+        // 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.
+        disallowedTools: ["AskUserQuestion"],
         hooks: { Stop: [{ hooks: [stopHookCheck] }] },
         ...(input.link.model ? { model: input.link.model } : {}),
         ...(input.sessionId ? { resume: input.sessionId } : {}),
       },
     });
+    const mapState = newStreamMapState();
     let result: string | null = null;
     for await (const message of q) {
       if (message.type === "system" && message.subtype === "init") outcome.sessionId = message.session_id;
-      if (message.type === "stream_event") {
-        const event = message.event;
-        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-          yieldedAny = true;
-          yield event.delta.text;
-        }
-      }
       if (message.type === "result") {
         outcome.sessionId = message.session_id;
         if (message.subtype === "success") result = message.result;
         else outcome.failed = true;
       }
+      for (const part of agentEventChunks({ state: mapState, message })) {
+        if (SegmentBreakSchema.safeParse(part).success) breakSegment();
+        else await push(SegmentChunkSchema.parse(part));
+      }
     }
     // a turn that produced no streamed text (tool-only turns) still reports.
-    if (!yieldedAny && result) yield result;
-    if (!yieldedAny && !result && outcome.failed) yield "the turn ended without a result (limit or error) - trying again may help";
+    if (!postedText && result) await push(result);
+    if (!postedText && !result && outcome.failed) await push("the turn ended without a result (limit or error) - trying again may help");
   } catch (e) {
     outcome.failed = true;
     const detail = (e instanceof Error ? e.message : String(e)).slice(0, 300);
     log("serve.turn_error", { err: detail });
-    yield `${yieldedAny ? "\n\n" : ""}tokenmaxxing: turn failed: ${detail}`;
+    await push(`tokenmaxxing: turn failed: ${detail}`);
   }
+  breakSegment();
+  await lastPost;
+  return outcome;
 }

package/src/lib/slackstate.ts

@@ -115,6 +115,12 @@ export function linkForChannel(cfg: SlackConfig, channel: string): SlackLink | n
   return cfg.links.find((l) => l.channel === channel) ?? null;
 }
 
+/** Chat SDK channel ids are adapter-prefixed ("slack:C0123"); links store the
+ *  bare Slack id, so lookups must strip the prefix. */
+export function bareChannelId(id: string): string {
+  return id.startsWith("slack:") ? id.slice("slack:".length) : id;
+}
+
 /** Strip a leading Slack mention token ("<@U0123> rest") from message text. */
 export function stripLeadingMention(text: string): string {
   const trimmed = text.trimStart();

package/src/lib/slackstream.ts

@@ -0,0 +1,192 @@
+// Maps Claude Agent SDK messages onto Chat SDK stream chunks so a relayed
+// Slack turn shows the agent's process natively: task cards for thinking and
+// tool calls (pending -> in_progress -> complete/error), streamed text via
+// markdown_text, and a closing turn card with model/cost/duration. Structured
+// chunks render only when the Slack app has the agent feature + assistant:write
+// (the adapter drops them gracefully otherwise); plain text streams either way.
+
+import { z } from "zod";
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { StreamChunk } from "chat";
+
+const DETAILS_MAX = 400;
+const OUTPUT_MAX = 600;
+
+/** Tool-input fields worth showing on a task card, most human-readable first. */
+const SUMMARY_FIELDS = ["command", "description", "file_path", "pattern", "prompt", "query", "url"] as const;
+
+const OpenBlockSchema = z.object({
+  kind: z.enum(["thinking", "tool"]),
+  id: z.string(),
+  title: z.string(),
+  /** accumulated thinking text or partial tool-input JSON. */
+  acc: z.string(),
+});
+type OpenBlock = z.infer<typeof OpenBlockSchema>;
+
+export const StreamMapStateSchema = z.object({
+  /** open content blocks by stream index. */
+  open: z.record(z.string(), OpenBlockSchema),
+  /** tool_use id -> tool name, for labeling the eventual tool_result. */
+  toolTitles: z.record(z.string(), z.string()),
+  thinkingCount: z.number(),
+  /** reply text streamed since the last segment break. */
+  textSinceBreak: z.boolean(),
+});
+export type StreamMapState = z.infer<typeof StreamMapStateSchema>;
+
+export function newStreamMapState(): StreamMapState {
+  return { open: {}, toolTitles: {}, thinkingCount: 0, textSinceBreak: false };
+}
+
+/** Emitted when a tool starts after streamed reply text: the bridge closes the
+ *  current Slack message there and posts the rest as a new one, mirroring how
+ *  an agent turn reads as separate messages around its tool runs. */
+export const SegmentBreakSchema = z.object({ type: z.literal("segment_break") });
+export type SegmentBreak = z.infer<typeof SegmentBreakSchema>;
+
+export const StreamPartSchema = z.union([z.string(), z.custom<StreamChunk>(), SegmentBreakSchema]);
+export type StreamPart = z.infer<typeof StreamPartSchema>;
+
+function truncate(input: { text: string; max: number }): string {
+  return input.text.length > input.max ? `${input.text.slice(0, input.max)}...` : input.text;
+}
+
+/** One human line out of a tool-input JSON blob; null when nothing fits. */
+export function toolInputSummary(rawJson: string): string | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(rawJson);
+  } catch {
+    return null; // partial or empty input JSON - show the bare tool name
+  }
+  const obj = z.record(z.string(), z.unknown()).safeParse(parsed);
+  if (!obj.success) return null;
+  for (const field of SUMMARY_FIELDS) {
+    const value = z.string().min(1).safeParse(obj.data[field]);
+    if (value.success) return truncate({ text: value.data, max: DETAILS_MAX });
+  }
+  const compact = JSON.stringify(parsed);
+  return compact === "{}" ? null : truncate({ text: compact, max: DETAILS_MAX });
+}
+
+const ToolResultBlockSchema = z.object({
+  type: z.literal("tool_result"),
+  tool_use_id: z.string(),
+  content: z.union([z.string(), z.array(z.unknown())]).optional(),
+  is_error: z.boolean().optional(),
+});
+
+const TextPartSchema = z.object({ type: z.literal("text"), text: z.string() });
+
+function resultText(content: z.infer<typeof ToolResultBlockSchema>["content"]): string | undefined {
+  if (content === undefined) return undefined;
+  const joined = Array.isArray(content)
+    ? content
+        .flatMap((part) => {
+          const p = TextPartSchema.safeParse(part);
+          return p.success ? [p.data.text] : [];
+        })
+        .join("\n")
+    : content;
+  const trimmed = joined.trim();
+  return trimmed === "" ? undefined : truncate({ text: trimmed, max: OUTPUT_MAX });
+}
+
+/**
+ * Consume one SDK message, mutating state, and return the stream chunks it
+ * produces (strings are streamed reply text; objects are native task cards).
+ * Subagent events (parent_tool_use_id set) contribute their TOOL cards to the
+ * timeline (user ask 2026-07-18: subagent activity shows as accordions like
+ * tool calls) but never reply text, thinking cards, or segment breaks: a
+ * subagent runs inside a top-level Task tool, so its churn decorates the
+ * current message rather than reshaping it. Open blocks are keyed per stream
+ * (parent + index) because concurrent subagent streams reuse index space.
+ */
+export function agentEventChunks(input: { state: StreamMapState; message: SDKMessage }): StreamPart[] {
+  const { state, message } = input;
+  if (message.type === "stream_event") {
+    const isMain = message.parent_tool_use_id === null;
+    const event = message.event;
+    if (event.type === "content_block_start") {
+      const key = `${message.parent_tool_use_id ?? "main"}:${event.index}`;
+      if (event.content_block.type === "thinking" && isMain) {
+        state.thinkingCount += 1;
+        const id = `thinking-${state.thinkingCount}`;
+        state.open[key] = { kind: "thinking", id, title: "Thinking", acc: "" };
+        return [{ type: "task_update", id, title: "Thinking", status: "in_progress" }];
+      }
+      if (event.content_block.type === "tool_use") {
+        const { id, name } = event.content_block;
+        state.open[key] = { kind: "tool", id, title: name, acc: "" };
+        state.toolTitles[id] = name;
+        const card: StreamPart = { type: "task_update", id, title: name, status: "in_progress" };
+        if (isMain && state.textSinceBreak) {
+          state.textSinceBreak = false;
+          return [{ type: "segment_break" }, card];
+        }
+        return [card];
+      }
+      return [];
+    }
+    if (event.type === "content_block_delta") {
+      const open = state.open[`${message.parent_tool_use_id ?? "main"}:${event.index}`];
+      if (event.delta.type === "text_delta") {
+        if (!isMain) return [];
+        // 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;
+      if (event.delta.type === "input_json_delta" && open) open.acc += event.delta.partial_json;
+      return [];
+    }
+    if (event.type === "content_block_stop") {
+      const key = `${message.parent_tool_use_id ?? "main"}:${event.index}`;
+      const open = state.open[key];
+      if (!open) return [];
+      delete state.open[key];
+      if (open.kind === "thinking") {
+        return [{ type: "task_update", id: open.id, title: open.title, status: "complete", details: truncate({ text: open.acc.trim(), max: DETAILS_MAX }) }];
+      }
+      const details = toolInputSummary(open.acc);
+      return [{ type: "task_update", id: open.id, title: open.title, status: "in_progress", ...(details ? { details } : {}) }];
+    }
+    return [];
+  }
+  if (message.type === "user") {
+    const content = message.message.content;
+    if (!Array.isArray(content)) return [];
+    const chunks: StreamChunk[] = [];
+    for (const block of content) {
+      const parsed = ToolResultBlockSchema.safeParse(block);
+      if (!parsed.success) continue;
+      const title = state.toolTitles[parsed.data.tool_use_id];
+      if (title === undefined) continue;
+      const output = resultText(parsed.data.content);
+      chunks.push({
+        type: "task_update",
+        id: parsed.data.tool_use_id,
+        title,
+        status: parsed.data.is_error === true ? "error" : "complete",
+        ...(output ? { output } : {}),
+      });
+    }
+    return chunks;
+  }
+  if (message.type === "result") {
+    const models = Object.keys(message.modelUsage).join(" ");
+    const cost = `$${message.total_cost_usd.toFixed(4)}`;
+    const secs = `${Math.round(message.duration_ms / 1000)}s`;
+    return [{
+      type: "task_update",
+      id: "turn",
+      title: "Turn",
+      status: message.subtype === "success" ? "complete" : "error",
+      details: [models, cost, secs].filter((p) => p !== "").join("  "),
+    }];
+  }
+  return [];
+}

package/src/lib/usage.ts

@@ -76,7 +76,7 @@ export function matchedFamily(model: ModelInfo | null, families: string[]): stri
  *  unknown. The unknown case matters on headless boxes: a swap clears the
  *  snapshots and only an actively-rendering statusLine restores the model, so
  *  the periodic check ran model-blind for hours while the active account sat at
- *  its Fable cap (the 2026-07-12 stella incident). */
+ *  its Fable cap (the 2026-07-12 ARM-box incident). */
 export function gatedFamilies(model: ModelInfo | null, families: string[]): string[] {
   if (!model) return families;
   const family = matchedFamily(model, families);