tokenmaxxing 0.17.0 → 0.18.0

package/DESIGN.md

@@ -28,7 +28,7 @@ It is a process/PTY manager only - spawn, forward the terminal, wait, restore te
 ## 2. What tokenmaxxing installs
 
 - A `claude` **supervisor** on your PATH ahead of the real binary (`~/.config/tokenmaxxing/bin/claude`), or a shell function - you invoke it identically.
-- Three `~/.claude/settings.json` entries (merged, preserving anything you already have): a transparent `statusLine` shim, a `Stop` hook, a `SessionStart` hook.
+- Four `~/.claude/settings.json` entries (merged, preserving anything you already have): a transparent `statusLine` shim, a `subagentStatusLine` shim (per-subagent rows in the agents panel), a `Stop` hook, a `SessionStart` hook.
 - **`~/.config/tokenmaxxing/`** - the single home for config and state:
   - `config.json` - threshold, account order/policy.
   - `accounts.json` - non-secret index `{email, organizationUuid, accountUuid, lastUsage, resetsAt, needs_reauth}`.
@@ -83,6 +83,18 @@ The decision engages at `five_hour >= 50%` (policy.greedySessionFloor): from the
 
 ---
 
+## 5b. The Slack bridge (`xx serve`, 0.18.0)
+
+A local Socket Mode daemon (no public URL) that turns Slack threads into Claude Code sessions on the pooled accounts. Stack (user decision 2026-07-18): Vercel's Chat SDK (`chat` + `@chat-adapter/slack`) for the Slack side; the Claude Agent SDK driven through `src/sdk.ts`'s pooled surface for the claude side - `xx serve` is that surface's first in-repo consumer. EVE (Vercel's agent framework) was researched and explicitly dropped: it owns its own model loop via AI Gateway, so it would replace Claude Code rather than drive it.
+
+- **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.
+
+---
+
 ## 6. Honest papercuts
 - **Respawn hiccup (depleted pause only).** Plain swaps never restart the session. When the whole pool is depleted you see `claude` stop, a countdown, and a resume; anything typed in the split second before the SIGTERM is lost, and the supervisor resets terminal mode so nothing is left garbled.
 - **Adoption lag.** macOS reads the keychain through a raw 30s cache, so at most the first turn after a swap can still meter the old account. The bars' headroom absorbs it.

package/README.md

@@ -45,6 +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 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.17.0",
+  "version": "0.18.0",
   "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",
@@ -40,6 +40,10 @@
     "typescript": "^5.6.0"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.214",
+    "@chat-adapter/slack": "^4.34.0",
+    "@chat-adapter/state-memory": "^4.34.0",
+    "chat": "^4.34.0",
     "es-toolkit": "^1.49.0",
     "ky": "^2.0.2",
     "zod": "^4.4.3"

package/src/cli/doctor.ts

@@ -33,6 +33,7 @@ export async function cmdDoctor(): Promise<number> {
 
   const s = checkSettings();
   check(s.statusLineOk, "statusLine shim installed in settings.json", "run `tokenmaxxing init`");
+  check(s.subagentStatusLineOk, "subagentStatusLine shim installed in settings.json", "run `tokenmaxxing init`");
   check(s.stopOk, "Stop hook installed in settings.json", "run `tokenmaxxing init`");
   check(s.sessionStartOk, "SessionStart hook installed in settings.json", "run `tokenmaxxing init`");
   check(checkTimerHealthy(), "periodic check timer active", timerActivationHint());

package/src/cli/render.ts

@@ -18,6 +18,33 @@ export function makeColors(enabled: boolean) {
 
 export const c = makeColors(!process.env.NO_COLOR && !!process.stdout.isTTY);
 
+/** Used% -> RGB on a continuous green->yellow->red ramp, anchored at the
+ *  semantic severity bands (pure green at 0, yellow at 75, red from 95) so the
+ *  band boundaries read exactly like the old 3-color scheme. Blue stays 0. */
+function rampRgb(usedPct: number): { r: number; g: number } {
+  const u = clamp(usedPct, 0, 100);
+  if (u >= 95) return { r: 255, g: 0 };
+  if (u >= 75) return { r: 255, g: Math.round(255 * (1 - (u - 75) / 20)) };
+  return { r: Math.round((255 * u) / 75), g: 255 };
+}
+
+/** Usage-severity painter for the statusLine (user decision 2026-07-18: colors
+ *  carry quota status instead of numbers). Truecolor when the terminal
+ *  advertises it, else the nearest 256-color cube step; disabled -> identity,
+ *  and callers must then fall back to numeric rendering (without color a
+ *  drained window must not look fresh). */
+export function makeUsagePaint(input: { enabled: boolean; truecolor: boolean }) {
+  return (usedPct: number) =>
+    (s: string): string => {
+      if (!input.enabled) return s;
+      const { r, g } = rampRgb(usedPct);
+      const code = input.truecolor
+        ? `38;2;${r};${g};0`
+        : `38;5;${16 + 36 * Math.round(r / 51) + 6 * Math.round(g / 51)}`;
+      return `\x1b[${code}m${s}\x1b[0m`;
+    };
+}
+
 /** Plan label for a claude account, e.g. "max 20x": subscription name plus the
  *  multiplier segment of the rate-limit tier id ("default_claude_max_20x").
  *  Structural, never exact-string: the multiplier is any <digits>x segment, so

package/src/cli/serve.ts

@@ -0,0 +1,266 @@
+// `tokenmaxxing serve` - the Slack bridge daemon. Socket Mode (no public URL):
+// a mention in a linked channel opens a claude session for that thread (in its
+// own git worktree by default), and every further thread message becomes one
+// claude turn whose streamed output posts back into the thread. Stack chosen by
+// the user 2026-07-18: Vercel Chat SDK (`chat` + `@chat-adapter/slack`) for
+// Slack, the Claude Agent SDK driven through src/sdk.ts for claude (EVE was
+// researched and dropped: it owns its own model loop instead of driving
+// Claude Code).
+//
+//   serve setup            print the app manifest + prompt for the two tokens
+//   serve link <ch> <repo> [--no-worktree] [--dangerous] [--model <m>]
+//   serve unlink <ch>      remove a link
+//   serve links            list links
+//   serve                  run the daemon
+
+import { existsSync, realpathSync } from "node:fs";
+import { Chat } from "chat";
+import { createSlackAdapter } from "@chat-adapter/slack";
+import { createMemoryState } from "@chat-adapter/state-memory";
+import {
+  isChannelId,
+  linkForChannel,
+  loadSlackConfig,
+  loadSlackThread,
+  removeLink,
+  saveSlackConfig,
+  saveSlackThread,
+  stripLeadingMention,
+  upsertLink,
+  SlackLinkSchema,
+  type SlackConfig,
+} from "../lib/slackstate.ts";
+import { ensureThreadCwd, relayTurn, type TurnOutcome } 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]";
+
+/** 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. */
+const APP_MANIFEST = `display_information:
+  name: tokenmaxxing
+  description: bridges Slack threads to Claude Code sessions
+
+features:
+  bot_user:
+    display_name: tokenmaxxing
+    always_online: true
+
+oauth_config:
+  scopes:
+    bot:
+      - app_mentions:read
+      - channels:history
+      - groups:history
+      - chat:write
+      - files:write
+      - users:read
+
+settings:
+  event_subscriptions:
+    bot_events:
+      - app_mention
+      - message.channels
+      - message.groups
+  socket_mode_enabled: true
+  org_deploy_enabled: false
+  token_rotation_enabled: false`;
+
+function printSetupInstructions(): void {
+  console.log(c.bold("Slack app setup (one time)"));
+  console.log(`1. Open ${c.cyan("https://api.slack.com/apps")} > Create New App > From an app manifest, pick your workspace, and paste:`);
+  console.log();
+  console.log(APP_MANIFEST);
+  console.log();
+  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.`);
+}
+
+function cmdServeSetup(): number {
+  printSetupInstructions();
+  console.log();
+  const botToken = prompt("bot token (xoxb-...):")?.trim();
+  const appToken = prompt("app token (xapp-...):")?.trim();
+  if (!botToken || !appToken) {
+    console.error(c.red("both tokens are required - nothing saved"));
+    return 1;
+  }
+  const existing = loadSlackConfig();
+  let cfg: SlackConfig;
+  try {
+    cfg = { botToken, appToken, links: existing?.links ?? [] };
+    saveSlackConfig(cfg);
+  } catch {
+    console.error(c.red("tokens rejected: the bot token must start with xoxb- and the app token with xapp-"));
+    return 1;
+  }
+  console.log(`${c.green("✓")} saved to slack.json (0600) with ${count({ n: cfg.links.length, noun: "link" })}`);
+  return 0;
+}
+
+function cmdServeLink(argv: string[]): number {
+  const worktree = !argv.includes("--no-worktree");
+  const dangerous = 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));
+  const [channel, repo] = rest;
+  if (!channel || !repo) {
+    console.error(SERVE_USAGE);
+    return 2;
+  }
+  if (!isChannelId(channel)) {
+    console.error(c.red(`"${channel}" is not a Slack channel id (C.../G...). In Slack: right-click the channel > View channel details - the id is at the bottom.`));
+    return 1;
+  }
+  if (!existsSync(repo)) {
+    console.error(c.red(`repo path does not exist: ${repo}`));
+    return 1;
+  }
+  const repoReal = realpathSync(repo);
+  if (!existsSync(`${repoReal}/.git`)) {
+    console.error(c.red(`${repoReal} is not a git repository (worktree mode needs one)`));
+    return 1;
+  }
+  const cfg = loadSlackConfig();
+  if (!cfg) {
+    console.error(c.red("no slack.json yet - run `tokenmaxxing serve setup` first"));
+    return 1;
+  }
+  const link = SlackLinkSchema.parse({
+    channel,
+    repo: repoReal,
+    worktree,
+    permissionMode: dangerous ? "bypassPermissions" : "acceptEdits",
+    ...(model ? { model } : {}),
+  });
+  saveSlackConfig(upsertLink(cfg, link));
+  const flags = [worktree ? "worktree" : "in-place", link.permissionMode, ...(model ? [model] : [])].join(", ");
+  console.log(`${c.green("✓")} linked ${c.bold(channel)} → ${repoReal} (${flags})`);
+  return 0;
+}
+
+function cmdServeUnlink(channel: string | undefined): number {
+  if (!channel) {
+    console.error(SERVE_USAGE);
+    return 2;
+  }
+  const cfg = loadSlackConfig();
+  const next = cfg ? removeLink(cfg, channel) : null;
+  if (!next) {
+    console.error(c.red(`no link for channel ${channel}`));
+    return 1;
+  }
+  saveSlackConfig(next);
+  console.log(`${c.green("✓")} unlinked ${channel}`);
+  return 0;
+}
+
+function cmdServeLinks(): number {
+  const cfg = loadSlackConfig();
+  if (!cfg || cfg.links.length === 0) {
+    console.log(c.dim("no channel links - run `tokenmaxxing serve link <channel-id> <repo>`"));
+    return 0;
+  }
+  for (const l of cfg.links) {
+    const flags = [l.worktree ? "worktree" : "in-place", l.permissionMode, ...(l.model ? [l.model] : [])].join(", ");
+    console.log(`${c.bold(l.channel)} → ${l.repo} ${c.dim(`(${flags})`)}`);
+  }
+  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) {
+    printSetupInstructions();
+    return 1;
+  }
+  if (cfg.links.length === 0) {
+    console.error(c.red("no channel links - run `tokenmaxxing serve link <channel-id> <repo>` first"));
+    return 1;
+  }
+
+  const slack = createSlackAdapter({ mode: "socket", botToken: cfg.botToken, appToken: cfg.appToken });
+  const bot = new Chat({
+    userName: "tokenmaxxing",
+    adapters: { slack },
+    state: createMemoryState(),
+    // 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",
+    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);
+    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));
+    if (outcome.sessionId !== record.sessionId) {
+      saveSlackThread({ ...record, sessionId: outcome.sessionId });
+    }
+  };
+
+  bot.onNewMention(async (thread, message) => {
+    await handleTurn(thread, message.text, 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);
+  });
+
+  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);
+    }
+  }
+}
+
+export async function cmdServe(argv: string[]): Promise<number> {
+  const [sub, ...rest] = argv;
+  switch (sub) {
+    case undefined: return runDaemon();
+    case "setup": return cmdServeSetup();
+    case "link": return cmdServeLink(rest);
+    case "unlink": return cmdServeUnlink(rest[0]);
+    case "links": return cmdServeLinks();
+    default:
+      console.error(SERVE_USAGE);
+      return 2;
+  }
+}

package/src/cli/status.ts

@@ -12,12 +12,13 @@
 // fallback: its own `/usage` fail-silents exactly when a live session is
 // running it, and that session's tee is fresher than any cache.
 
+import { sortBy } from "es-toolkit";
 import { loadAccounts, loadConfig, loadUsage, loadModelUsage, saveAccounts } from "../lib/state.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { probeActiveUsage, probeParkedUsage, type SampleOutcome } from "../lib/sample.ts";
 import { withLock } from "../lib/lock.ts";
 import { codexPaths, paths } from "../lib/paths.ts";
-import { effectiveBars, isExhausted, nextWeeklyReset } from "../lib/picker.ts";
+import { earliestReset, effectiveBars, isExhausted, nextWeeklyReset } from "../lib/picker.ts";
 import { loadCodexAccounts, saveCodexAccounts } from "../lib/codexstate.ts";
 import { liveCodexAccountId, sampleCodexAccount, type CodexSampleOutcome } from "../lib/codexsample.ts";
 import { isCodexExhausted } from "../lib/codexpick.ts";
@@ -115,7 +116,11 @@ export async function cmdStatus(force = false, preRender?: () => void): Promise<
     console.log(`    ${name.padEnd(5)} ${bar(pct)}  ${c.dim(fmtReset(resetsAt, now))}`);
   };
 
-  for (const a of idx.accounts) {
+  // Display order (user decision 2026-07-18): earliest upcoming reset first
+  // (5h or extrapolated weekly, from the just-refreshed samples), needs-reauth
+  // last; the ● marker identifies the active account wherever it sorts.
+  const displayAccounts = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
+  for (const a of displayAccounts) {
     const active = a.accountUuid === idx.activeAccountUuid;
     const outcome = outcomes.get(a.accountUuid);
     const failed = outcome ? !outcome.ok : false;
@@ -200,7 +205,17 @@ async function renderCodexSection(input: {
   console.log();
   const windowLabel = (window: CodexWindow) =>
     isSessionWindow({ window }) ? `${Math.round((window.windowSeconds ?? 0) / 3600)}h` : "week";
-  for (const account of index.accounts) {
+  // Same display order as the claude pool: earliest upcoming reset first
+  // across every cached window, needs-reauth last.
+  const displayAccounts = sortBy(index.accounts, [
+    (a) => (a.needsReauth ? 1 : 0),
+    (a) => {
+      const windows = [...(a.lastUsage?.aggregate ?? []), ...Object.values(a.lastUsage?.perLimit ?? {}).flat()];
+      const resets = windows.flatMap((w) => (w.resetsAt != null && w.resetsAt > now ? [w.resetsAt] : []));
+      return resets.length > 0 ? Math.min(...resets) : Number.POSITIVE_INFINITY;
+    },
+  ]);
+  for (const account of displayAccounts) {
     const active = account.accountId === liveId;
     const marker = active ? c.green("●") : c.dim("○");
     const badges: string[] = [];

package/src/entries/statusline.ts

@@ -1,14 +1,18 @@
 // Native statusLine. Reads Claude's statusLine stdin, tees the rate-limit data
 // to usage.json (write-on-change, O(ms)), then renders ONE line:
-//   worktree name (linked worktrees only), model (effort), ctx used,
-//   +added/-removed, then quota as USED percent (bold, severity-colored)
-//   glued after its time-to-reset: "◆ F26 2h5 1d38  ◇ F67 2d40  ◇ 2 full"
-//   ("2h5" = resets in 2h, 5 used) - the active account's windows after a
-//   green ◆ (per-model by initial first, "F?" when the cap applies but is
-//   unmeasured, then session/5h, then week), then each parked account's week
-//   after a cyan ◇, in swap-preference order so the first usable ◇ is where
-//   the next swap lands. Adjacent untouched (or unsampled) parked accounts
-//   collapse into one counted token. Blocks are joined by TWO spaces, tokens
+//   worktree name (linked worktrees only), model name painted by context fill
+//   (effort in parens), +added/-removed, then quota as COLOR (user decisions
+//   2026-07-18): each window is its time-to-reset painted on a continuous
+//   green->yellow->red ramp by used% - "◆ 𝒇 2h 1d  ◇ 2d  ◇ full" - the
+//   active account's windows after a green ◆ (per-model by bare initial
+//   first, fable as 𝒇, other families uppercased; "𝒇?" unpainted when the
+//   cap applies but is unmeasured, then session/5h, then week), then EVERY
+//   parked account's week after its own cyan ◇ (red ✗ if needs-reauth),
+//   sorted by earliest upcoming reset (needs-reauth last). A window with no
+//   upcoming reset renders "0" (empty again); measured usage with an unknown
+//   reset clock renders a painted "?". With color disabled the numeric format
+//   returns ("2h5" = resets in 2h, 5 used; "ctx 42"): without color a drained
+//   window must not look fresh. Blocks are joined by TWO spaces, tokens
 //   within a block by one. Per-model resets are omitted (they match the
 //   weekly reset).
 // Must NEVER break the status line: render what parses, skip what doesn't.
@@ -17,14 +21,13 @@ import { sortBy } from "es-toolkit";
 import { z } from "zod";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { loadAccounts, loadConfig, loadLastSwapAt, loadModelUsage, writeUsage } from "../lib/state.ts";
-import { familyTokens, gatedFamilies, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
-import { effectiveBars, isExhausted, swapPreference, weeklyExpiry } from "../lib/picker.ts";
+import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
+import { earliestReset, weeklyExpiry } from "../lib/picker.ts";
 import { worktreeName } from "../lib/worktree.ts";
-import { fmtResetShort, makeColors } from "../cli/render.ts";
+import { fmtResetShort, makeColors, makeUsagePaint } from "../cli/render.ts";
 import {
   AccountsIndexSchema,
   StatusLineStdinSchema,
-  ThresholdsSchema,
   UsageWindowSchema,
   type Account,
   type UsageState,
@@ -42,15 +45,16 @@ const RenderCtxSchema = z.object({
   perModel: z.record(z.string(), UsageWindowSchema),
   /** families (lowercased) whose per-model weekly cap gates a switch. */
   switchModels: z.array(z.string()),
-  thresholds: ThresholdsSchema,
   /** linked-worktree basename, null in a main checkout. */
   worktree: z.string().nullable(),
   now: z.number(),
   color: z.boolean(),
+  /** terminal advertises 24-bit color (COLORTERM); false steps the ramp to the 256-color cube. */
+  truecolor: z.boolean(),
 });
 export type RenderCtx = z.infer<typeof RenderCtxSchema>;
 
-async function readStdin(): Promise<string> {
+export async function readStdin(): Promise<string> {
   const chunks: Uint8Array[] = [];
   for await (const c of Bun.stdin.stream()) chunks.push(c);
   return Buffer.concat(chunks).toString("utf8");
@@ -59,8 +63,7 @@ async function readStdin(): Promise<string> {
 /** Pure renderer: statusLine stdin + tokenmaxxing state → the emitted line. */
 export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const col = makeColors(ctx.color);
-  const severity = (u: number) => (u >= 95 ? col.red : u >= 75 ? col.yellow : col.green);
-  const gauge = (u: number) => col.bold(severity(u)(`${Math.round(u)}`));
+  const paint = makeUsagePaint({ enabled: ctx.color, truecolor: ctx.truecolor });
   // Used quota in a window; one whose reset has passed is empty again.
   const used = (w: UsageWindow) => (w.resetsAt != null && w.resetsAt <= ctx.now ? 0 : w.usedPercentage);
   const reset = (epochMs: number | null) => fmtResetShort(epochMs, ctx.now);
@@ -71,29 +74,43 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   // ---- info block: worktree, model, ctx, diff
   const info: string[] = [];
   if (ctx.worktree != null) info.push(ctx.worktree);
+  // The model name carries the context-fill color (user rule 2026-07-18, no
+  // ctx token); colorless mode keeps the numeric ctx token instead.
   const modelName = d?.model?.display_name ?? d?.model?.id;
+  const ctxUsed = d?.context_window?.used_percentage;
   if (modelName) {
     const effort = d?.effort?.level;
-    info.push(col.bold(modelName) + (effort ? ` (${effort})` : ""));
+    const body = ctxUsed != null ? col.bold(paint(ctxUsed)(modelName)) : col.bold(modelName);
+    info.push(body + (effort ? ` (${effort})` : ""));
   }
-  const ctxUsed = d?.context_window?.used_percentage;
-  if (ctxUsed != null) info.push(`ctx ${gauge(ctxUsed)}`);
+  if (!ctx.color && ctxUsed != null) info.push(`ctx ${Math.round(ctxUsed)}`);
   const added = d?.cost?.total_lines_added ?? 0;
   const removed = d?.cost?.total_lines_removed ?? 0;
   // -removed stays unpainted: red means quota alarm and nothing else.
   if (added > 0 || removed > 0) info.push(`${col.green(`+${added}`)}/-${removed}`);
 
   // ---- active account block
-  const seg = (label: string, w: UsageWindow, resetAt: number | null) =>
-    `${label}${reset(resetAt)}${gauge(used(w))}`;
+  // A window token: color carries the used%, the text is the reset countdown
+  // (or the bare per-model initial - per-model resets are omitted). "0" = no
+  // upcoming reset (the window is empty again); a painted "?" = measured usage
+  // whose reset clock is unknown. Colorless mode glues the number back on.
+  const seg = (label: string, w: UsageWindow, resetAt: number | null) => {
+    const u = used(w);
+    if (!ctx.color) return `${label}${reset(resetAt)}${Math.round(u)}`;
+    const body = label !== "" ? label : reset(resetAt);
+    return col.bold(paint(u)(body !== "" ? body : u > 0 ? "?" : "0"));
+  };
+  // Per-model initial: fable renders 𝒇 (user rule 2026-07-18), family-matched
+  // as always; other families keep their uppercased first letter.
+  const initial = (name: string) => (familyTokens(name).includes("fable") ? "𝒇" : name.slice(0, 1).toUpperCase());
   const wins = parseStatusLineStdin(stdinObj);
   const windows: string[] = [];
   // A capacity-constrained model whose cap is unmeasured must not look safe.
   const family = matchedFamily(parseStatusLineModel(stdinObj), ctx.switchModels);
   if (family && !Object.keys(ctx.perModel).some((k) => familyTokens(k).includes(family))) {
-    windows.push(`${family[0]!.toUpperCase()}?`);
+    windows.push(`${initial(family)}?`);
   }
-  for (const [name, w] of Object.entries(ctx.perModel)) windows.push(seg(name.slice(0, 1), w, null));
+  for (const [name, w] of Object.entries(ctx.perModel)) windows.push(seg(initial(name), w, null));
   if (wins) {
     windows.push(seg("", wins.fiveHour, wins.fiveHour.resetsAt));
     windows.push(seg("", wins.sevenDay, wins.sevenDay.resetsAt));
@@ -105,49 +122,31 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
         ? `${col.green("◆")} ?`
         : "";
 
-  // ---- parked accounts, in swap order: the first usable ◇ is the next target
-  const pickCtx = {
-    now: ctx.now,
-    thresholds: ctx.thresholds,
-    currentAccountUuid: ctx.accounts.activeAccountUuid,
-    switchFamilies: gatedFamilies(parseStatusLineModel(stdinObj), ctx.switchModels),
-  };
+  // ---- parked accounts, earliest upcoming reset first (needs-reauth last)
   const parked = sortBy(
     ctx.accounts.accounts.filter((a) => a.accountUuid !== ctx.accounts.activeAccountUuid),
-    [(a) => (a.needsReauth || isExhausted(a, pickCtx) ? 1 : 0), ...swapPreference(ctx.now)],
+    [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, ctx.now)],
   );
-  const poolSeg = (a: Account): { kind: "full" | "unknown" | "other"; text: string } => {
+  // Every parked account renders its own marker (user rule 2026-07-18: the
+  // old counted collapse "◇ 3 full" hid the pool size and read as confusing).
+  const poolSeg = (a: Account): string => {
     const marker = a.needsReauth ? col.red("✗") : col.cyan("◇");
-    const mergeable = !a.needsReauth;
-
     const week = a.lastUsage?.sevenDay;
-    if (week == null) return { kind: mergeable ? "unknown" : "other", text: `${marker} ?` };
+    if (week == null) return `${marker} ?`;
     const weekUsed = used(week);
-    if (Math.round(weekUsed) <= 0) return { kind: mergeable ? "full" : "other", text: `${marker} ${col.green("full")}` };
+    if (Math.round(weekUsed) <= 0) return `${marker} ${paint(0)("full")}`;
 
     const parts: string[] = [];
     // A per-model weekly cap with more used than the aggregate is the binding constraint - surface it.
     for (const [name, w] of Object.entries(a.lastPerModel ?? {})) {
-      if (used(w) > weekUsed) parts.push(seg(name.slice(0, 1), w, null));
+      if (used(w) > weekUsed) parts.push(seg(initial(name), w, null));
     }
     const expiry = weeklyExpiry(a, ctx.now);
     parts.push(seg("", week, Number.isFinite(expiry) ? expiry : null));
-    return { kind: "other", text: `${marker} ${parts.join(" ")}` };
+    return `${marker} ${parts.join(" ")}`;
   };
 
-  // Adjacent identical bare tokens collapse into one counted token ("◇ 3 full").
-  const pool: string[] = [];
-  const segs = parked.map(poolSeg);
-  for (let i = 0; i < segs.length; ) {
-    const s = segs[i]!;
-    let j = i + 1;
-    while (s.kind !== "other" && j < segs.length && segs[j]!.kind === s.kind) j++;
-    if (j - i >= 2) pool.push(`${col.cyan("◇")} ${j - i} ${s.kind === "full" ? col.green("full") : "?"}`);
-    else pool.push(s.text);
-    i = j;
-  }
-
-  return [info.join(" "), active, ...pool].filter((l) => l !== "").join("  ");
+  return [info.join(" "), active, ...parked.map(poolSeg)].filter((l) => l !== "").join("  ");
 }
 
 export async function runStatusline(): Promise<number> {
@@ -178,14 +177,15 @@ export async function runStatusline(): Promise<number> {
   const modelUsage = loadModelUsage();
   const stdin = StatusLineStdinSchema.safeParse(obj);
   const dir = stdin.success ? (stdin.data.workspace?.current_dir ?? stdin.data.workspace?.project_dir ?? null) : null;
+  const colorterm = z.string().optional().parse(process.env.COLORTERM);
   const ctx: RenderCtx = {
     accounts: loadAccounts(),
     perModel: modelUsage && modelUsage.org === org ? modelUsage.perModel : {},
     switchModels: cfg.policy.switchModels,
-    thresholds: effectiveBars(cfg),
     worktree: dir == null ? null : worktreeName(dir),
     now,
     color: !process.env.NO_COLOR,
+    truecolor: colorterm != null && (colorterm.includes("truecolor") || colorterm.includes("24bit")),
   };
   process.stdout.write(renderStatusline(obj, ctx) + "\n");
   return 0;

package/src/entries/subagentstatusline.ts

@@ -0,0 +1,78 @@
+// Renders claude's subagentStatusLine: one {id, content} JSON line per active
+// subagent task, so the agents panel shows each subagent's model, effort, and
+// ctx fill the way the main statusline shows the session's (user ask
+// 2026-07-18). This per-row panel surface is the only place subagent info can
+// appear: the main statusLine command never learns which subagent the UI is
+// viewing (verified against the 2.1.214 bundle). Row shape mirrors the main
+// info block, info first so claude's end-truncation eats the label instead:
+//   "fable (high)  <task label>" - the family name painted by the task's
+//   context fill (colorless mode keeps a numeric ctx token).
+// A task we emit nothing for keeps claude's default row (emitting empty
+// content would HIDE it). Must NEVER break the panel: render what parses,
+// skip what doesn't.
+
+import { z } from "zod";
+import { makeColors, makeUsagePaint } from "../cli/render.ts";
+import { readStdin } from "./statusline.ts";
+import { SubagentStatusLineStdinSchema } from "../lib/types.ts";
+
+const RowCtxSchema = z.object({ color: z.boolean(), truecolor: z.boolean() });
+export type RowCtx = z.infer<typeof RowCtxSchema>;
+
+/** "claude-fable-5" -> "fable" (lowercase family, matching the chart-label
+ *  convention); an id without the claude- prefix passes through whole. */
+function modelFamily(id: string): string {
+  const [head, family] = id.split("-");
+  return head === "claude" && family ? family : id;
+}
+
+/** Pure renderer: subagentStatusLine stdin -> {id, content} JSON lines. */
+export function renderSubagentRows(stdinObj: unknown, ctx: RowCtx): string[] {
+  const parsed = SubagentStatusLineStdinSchema.safeParse(stdinObj);
+  if (!parsed.success) return [];
+  const col = makeColors(ctx.color);
+  const paint = makeUsagePaint({ enabled: ctx.color, truecolor: ctx.truecolor });
+
+  const rows: string[] = [];
+  for (const t of parsed.data.tasks ?? []) {
+    if (t.id == null) continue;
+    const pct =
+      t.tokenCount != null && t.contextWindowSize != null && t.contextWindowSize > 0
+        ? Math.round((t.tokenCount / t.contextWindowSize) * 100)
+        : null;
+    const info: string[] = [];
+    // The model name carries the task's context-fill color (same rule as the
+    // main line); colorless mode keeps the numeric ctx token instead.
+    if (t.model != null) {
+      const family = modelFamily(t.model);
+      const body = pct != null ? col.bold(paint(pct)(family)) : col.bold(family);
+      info.push(body + (t.effort ? ` (${t.effort})` : ""));
+    }
+    if (!ctx.color && pct != null) info.push(`ctx ${pct}`);
+
+    const label = t.label ?? t.description ?? t.name;
+    const parts: string[] = [];
+    if (info.length > 0) parts.push(info.join(" "));
+    if (label != null && label !== "") parts.push(label);
+    if (parts.length === 0) continue;
+    rows.push(JSON.stringify({ id: t.id, content: parts.join("  ") }));
+  }
+  return rows;
+}
+
+export async function runSubagentStatusline(): Promise<number> {
+  const raw = await readStdin();
+  let obj: unknown = null;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    // malformed stdin - emit nothing, claude keeps its default rows
+  }
+  const colorterm = z.string().optional().parse(process.env.COLORTERM);
+  const rows = renderSubagentRows(obj, {
+    color: !process.env.NO_COLOR,
+    truecolor: colorterm != null && (colorterm.includes("truecolor") || colorterm.includes("24bit")),
+  });
+  if (rows.length > 0) process.stdout.write(rows.join("\n") + "\n");
+  return 0;
+}

package/src/lib/paths.ts

@@ -35,6 +35,13 @@ export const paths = {
   /** linux only: parked credential .json files (0700 dir, 0600 files). */
   credsDir: join(TM_HOME, "creds"),
 
+  /** `xx serve` slack bridge: tokens + channel->repo links (0600: holds the
+   *  xoxb-/xapp- tokens), per-thread claude session records, and the git
+   *  worktrees threads run in. */
+  slackJson: join(TM_HOME, "slack.json"),
+  slackThreadsDir: join(TM_HOME, "slack-threads"),
+  slackWorktreesDir: join(TM_HOME, "slack-worktrees"),
+
   /** ~/.claude.json - holds the active `oauthAccount` identity object. */
   claudeJson: env("TOKENMAXXING_CLAUDE_JSON", join(HOME, ".claude.json")),
   /** ~/.claude/settings.json - user-owned; we merge three entries into it. */

package/src/lib/picker.ts

@@ -98,6 +98,16 @@ export function weeklyExpiry(a: Account, now: number): number {
   return nextWeeklyReset(a.lastUsage?.sevenDay.resetsAt ?? null, now) ?? Number.POSITIVE_INFINITY;
 }
 
+/** Soonest upcoming reset among the account's cached windows: the 5h session
+ *  reset if still ahead, else the extrapolated weekly expiry; Infinity with no
+ *  known reset anchor (sorts last). Display order for `status` and the
+ *  statusLine pool (user decision 2026-07-18) - deliberately decoupled from
+ *  swapPreference, which keeps ranking actual swaps. */
+export function earliestReset(a: Account, now: number): number {
+  const fiveHour = a.lastUsage?.fiveHour.resetsAt;
+  return Math.min(fiveHour != null && fiveHour > now ? fiveHour : Number.POSITIVE_INFINITY, weeklyExpiry(a, now));
+}
+
 /** How far behind its own weekly pace the account is, measured forward: the
  *  burn rate (percent per ms) its remaining weekly quota must be consumed at
  *  to beat the reset that forfeits it. A backward-looking used/expected ratio
@@ -116,8 +126,7 @@ export function pacePressure(a: Account, now: number): number {
 
 /** The switch preference: furthest behind its own weekly pace first (highest
  *  pacePressure), tiebreak soonest weekly expiry then lowest 7-day usage.
- *  Shared with the statusLine pool ordering so the display order IS the
- *  swap order. */
+ *  Ranks swaps only; display surfaces order by earliestReset instead. */
 export const swapPreference = (now: number) => [
   (a: Account) => -pacePressure(a, now),
   (a: Account) => weeklyExpiry(a, now),

package/src/lib/settings.ts

@@ -1,7 +1,8 @@
-// Idempotent merge of tokenmaxxing's three entries into the user-owned
-// ~/.claude/settings.json: our statusLine, a Stop hook, a SessionStart hook.
-// Hooks APPEND to existing arrays; the statusLine slot is ours outright -
-// tokenmaxxing renders it natively, so any other statusLine command is replaced.
+// Idempotent merge of tokenmaxxing's entries into the user-owned
+// ~/.claude/settings.json: our statusLine + subagentStatusLine, a Stop hook,
+// a SessionStart hook. Hooks APPEND to existing arrays; the statusLine slots
+// are ours outright - tokenmaxxing renders them natively, so any other
+// statusLine command is replaced.
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -19,6 +20,7 @@ const HookGroupSchema = z.looseObject({ matcher: z.string().optional(), hooks: z
 const StatusLineSchema = z.looseObject({ type: z.string(), command: z.string() });
 const SettingsSchema = z.looseObject({
   statusLine: StatusLineSchema.optional(),
+  subagentStatusLine: StatusLineSchema.optional(),
   hooks: z.record(z.string(), z.array(HookGroupSchema)).optional(),
 });
 type Settings = z.infer<typeof SettingsSchema>;
@@ -26,6 +28,7 @@ type HookGroup = z.infer<typeof HookGroupSchema>;
 
 const SUBCMD = {
   statusline: "__statusline",
+  subagentStatusline: "__subagent-statusline",
   stop: "__stop-hook",
   sessionStart: "__session-start",
 } as const;
@@ -44,6 +47,7 @@ export function isOurCommand(cmd: string | undefined): boolean {
   if (!cmd) return false;
   return (
     cmd.includes(SUBCMD.statusline) ||
+    cmd.includes(SUBCMD.subagentStatusline) ||
     cmd.includes(SUBCMD.stop) ||
     cmd.includes(SUBCMD.sessionStart) ||
     // also match the installed bin path even if the subcommand text changes
@@ -70,29 +74,35 @@ function removeHook(s: Settings, event: string, sub: string): void {
   if (s.hooks![event]!.length === 0) delete s.hooks![event];
 }
 
-/** Install the three entries: take the statusLine slot, append our hooks. */
+/** Install the entries: take both statusLine slots, append our hooks. */
 export function installSettings(): void {
   const s = readSettings();
   s.statusLine = {
     type: "command",
     command: `${JSON.stringify(installedBin())} ${SUBCMD.statusline}`,
   };
+  s.subagentStatusLine = {
+    type: "command",
+    command: `${JSON.stringify(installedBin())} ${SUBCMD.subagentStatusline}`,
+  };
   appendHook(s, "Stop", SUBCMD.stop);
   appendHook(s, "SessionStart", SUBCMD.sessionStart);
   writeSettings(s);
 }
 
-/** Remove our three entries. The statusLine slot is deleted only if it is ours. */
+/** Remove our entries. The statusLine slots are deleted only if they are ours. */
 export function uninstallSettings(): void {
   const s = readSettings();
   removeHook(s, "Stop", SUBCMD.stop);
   removeHook(s, "SessionStart", SUBCMD.sessionStart);
   if (s.statusLine && isOurCommand(s.statusLine.command)) delete s.statusLine;
+  if (s.subagentStatusLine && isOurCommand(s.subagentStatusLine.command)) delete s.subagentStatusLine;
   writeSettings(s);
 }
 
 const SettingsCheckSchema = z.object({
   statusLineOk: z.boolean(),
+  subagentStatusLineOk: z.boolean(),
   stopOk: z.boolean(),
   sessionStartOk: z.boolean(),
 });
@@ -104,6 +114,7 @@ export function checkSettings(): SettingsCheck {
     !!s.hooks?.[event]?.some((g) => g.hooks?.some((h) => h.command?.includes(sub)));
   return {
     statusLineOk: isOurCommand(s.statusLine?.command),
+    subagentStatusLineOk: isOurCommand(s.subagentStatusLine?.command),
     stopOk: has("Stop", SUBCMD.stop),
     sessionStartOk: has("SessionStart", SUBCMD.sessionStart),
   };

package/src/lib/slackbridge.ts

@@ -0,0 +1,107 @@
+// The Slack->claude relay. One claude turn per Slack message via the Agent SDK
+// (re-query with resume, never a persistent streaming query: the SDK subprocess
+// reads credentials at spawn, so per-turn spawns are what let the pool decision
+// pick the freshest account at every boundary and let the daemon restart
+// without losing threads). Verified against @anthropic-ai/claude-agent-sdk
+// 0.3.214 and code.claude.com/docs 2026-07-18; both change monthly.
+
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { ensureBestAccount, pooledOptions, stopHookCheck } from "../sdk.ts";
+import { paths } from "./paths.ts";
+import { threadKey, type SlackLink } from "./slackstate.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. */
+export const TurnOutcomeSchema = z.object({
+  sessionId: z.string().nullable(),
+  failed: z.boolean(),
+});
+export type TurnOutcome = z.infer<typeof TurnOutcomeSchema>;
+
+/** 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" });
+  const stderr = new TextDecoder().decode(r.stderr).trim();
+  if (r.exitCode !== 0) throw new Error(`git ${args[0]} failed: ${stderr.slice(0, 200)}`);
+  return new TextDecoder().decode(r.stdout).trim();
+}
+
+/**
+ * The stable cwd a thread's turns run in. Worktree mode (default) creates
+ * `slack-worktrees/<threadKey>` on branch `tm-slack-<threadKey>` cut from the
+ * repo's current HEAD, once; both survive daemon restarts because resume is
+ * cwd-keyed. Worktrees are never auto-deleted (they hold the thread's work):
+ * clean up with `git worktree remove` when done.
+ */
+export function ensureThreadCwd(input: { link: SlackLink; threadId: string }): string {
+  if (!input.link.worktree) return input.link.repo;
+  const key = threadKey(input.threadId);
+  const dir = join(paths.slackWorktreesDir, key);
+  if (existsSync(dir)) return dir;
+  mkdirSync(paths.slackWorktreesDir, { recursive: true });
+  const branch = `tm-slack-${key}`;
+  const branchExists = Bun.spawnSync(["git", "-C", input.link.repo, "rev-parse", "--verify", "--quiet", branch]).exitCode === 0;
+  // a crash between branch creation and worktree add leaves the branch behind;
+  // reattach instead of failing on -b collision.
+  if (branchExists) git(input.link.repo, ["worktree", "add", dir, branch]);
+  else git(input.link.repo, ["worktree", "add", dir, "-b", branch]);
+  log("serve.worktree_created", { dir, branch });
+  return dir;
+}
+
+/**
+ * One claude turn, yielded as streaming text deltas (feed directly to
+ * thread.post). Never throws: a failure yields 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;
+  try {
+    // the switch decision runs at the spawn boundary, same as the CLI hooks.
+    await ensureBestAccount();
+    const q = query({
+      prompt: input.prompt,
+      options: {
+        ...pooledOptions(),
+        cwd: input.cwd,
+        permissionMode: input.link.permissionMode,
+        includePartialMessages: true,
+        hooks: { Stop: [{ hooks: [stopHookCheck] }] },
+        ...(input.link.model ? { model: input.link.model } : {}),
+        ...(input.sessionId ? { resume: input.sessionId } : {}),
+      },
+    });
+    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;
+      }
+    }
+    // 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";
+  } 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}`;
+  }
+}

package/src/lib/slackstate.ts

@@ -0,0 +1,125 @@
+// `xx serve` state. slack.json holds the Slack tokens plus the channel->repo
+// links; it is credential material (xoxb-/xapp-), so it is written 0600 and its
+// tokens must never be printed. Per-thread records under slack-threads/ pin the
+// claude session id + cwd a Slack thread resumes into (resume is cwd-keyed, so
+// the cwd must stay byte-stable for the thread's whole life). A present but
+// unparseable slack.json THROWS (no silent empty config); absent = null.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { paths } from "./paths.ts";
+import { writeFileAtomic } from "./atomic.ts";
+
+/** Claude Agent SDK permission modes an unattended bridge may run under.
+ *  acceptEdits (default) auto-approves file edits but not arbitrary Bash;
+ *  bypassPermissions is full autonomy - a per-link, user-chosen risk posture. */
+export const ServePermissionModeSchema = z.enum(["default", "acceptEdits", "bypassPermissions", "dontAsk", "plan"]);
+
+export const SlackLinkSchema = z.object({
+  /** Slack channel id (C.../G...). Names are not stored - ids are stable. */
+  channel: z.string(),
+  /** absolute path of the git repo this channel drives. */
+  repo: z.string(),
+  /** run each thread in its own git worktree (user default 2026-07-18: true). */
+  worktree: z.boolean().default(true),
+  permissionMode: ServePermissionModeSchema.default("acceptEdits"),
+  /** optional model override for this repo's sessions. */
+  model: z.string().optional(),
+});
+export type SlackLink = z.infer<typeof SlackLinkSchema>;
+
+export const SlackConfigSchema = z.object({
+  botToken: z.string().startsWith("xoxb-"),
+  appToken: z.string().startsWith("xapp-"),
+  links: z.array(SlackLinkSchema).default([]),
+});
+export type SlackConfig = z.infer<typeof SlackConfigSchema>;
+
+export function loadSlackConfig(): SlackConfig | null {
+  if (!existsSync(paths.slackJson)) return null;
+  return SlackConfigSchema.parse(JSON.parse(readFileSync(paths.slackJson, "utf8")));
+}
+
+export function saveSlackConfig(cfg: SlackConfig): void {
+  writeFileAtomic(paths.slackJson, JSON.stringify(SlackConfigSchema.parse(cfg), null, 2) + "\n", 0o600);
+}
+
+/** A Slack channel id: C (public) or G (private/legacy) followed by uppercase
+ *  alphanumerics. Structural check, no regex. */
+export function isChannelId(s: string): boolean {
+  if (s.length < 2 || (s[0] !== "C" && s[0] !== "G")) return false;
+  const rest = s.slice(1);
+  return [...rest].every((ch) => (ch >= "0" && ch <= "9") || (ch >= "A" && ch <= "Z"));
+}
+
+// ---- per-thread session records -------------------------------------------
+
+export const SlackThreadSchema = z.object({
+  /** chat-sdk thread id, e.g. "slack:C0123:1721300000.123456". */
+  threadId: z.string(),
+  repo: z.string(),
+  /** the dir every turn of this thread runs in (repo or its worktree). */
+  cwd: z.string(),
+  /** claude session id; null until the first turn's init message arrives. */
+  sessionId: z.string().nullable(),
+  createdAt: z.string(),
+});
+export type SlackThread = z.infer<typeof SlackThreadSchema>;
+
+/** Filesystem-safe key for a thread id: alnum kept, everything else "-". */
+export function threadKey(threadId: string): string {
+  return [...threadId]
+    .map((ch) => ((ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") || (ch >= "0" && ch <= "9") ? ch : "-"))
+    .join("");
+}
+
+function threadFile(threadId: string): string {
+  return join(paths.slackThreadsDir, `${threadKey(threadId)}.json`);
+}
+
+export function loadSlackThread(threadId: string): SlackThread | null {
+  const f = threadFile(threadId);
+  if (!existsSync(f)) return null;
+  return SlackThreadSchema.parse(JSON.parse(readFileSync(f, "utf8")));
+}
+
+export function saveSlackThread(t: SlackThread): void {
+  writeFileAtomic(threadFile(t.threadId), JSON.stringify(SlackThreadSchema.parse(t), null, 2) + "\n");
+}
+
+export function listSlackThreads(): SlackThread[] {
+  if (!existsSync(paths.slackThreadsDir)) return [];
+  const out: SlackThread[] = [];
+  for (const f of readdirSync(paths.slackThreadsDir)) {
+    if (!f.endsWith(".json")) continue;
+    out.push(SlackThreadSchema.parse(JSON.parse(readFileSync(join(paths.slackThreadsDir, f), "utf8"))));
+  }
+  return out;
+}
+
+// ---- pure link edits (unit-tested) ----------------------------------------
+
+export function upsertLink(cfg: SlackConfig, link: SlackLink): SlackConfig {
+  const links = cfg.links.filter((l) => l.channel !== link.channel);
+  links.push(link);
+  return { ...cfg, links };
+}
+
+export function removeLink(cfg: SlackConfig, channel: string): SlackConfig | null {
+  if (!cfg.links.some((l) => l.channel === channel)) return null;
+  return { ...cfg, links: cfg.links.filter((l) => l.channel !== channel) };
+}
+
+export function linkForChannel(cfg: SlackConfig, channel: string): SlackLink | null {
+  return cfg.links.find((l) => l.channel === channel) ?? null;
+}
+
+/** Strip a leading Slack mention token ("<@U0123> rest") from message text. */
+export function stripLeadingMention(text: string): string {
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith("<@")) return text.trim();
+  const close = trimmed.indexOf(">");
+  if (close < 0) return text.trim();
+  return trimmed.slice(close + 1).trim();
+}

package/src/lib/types.ts

@@ -196,6 +196,28 @@ export const StatusLineStdinSchema = RateLimitsStdinSchema.extend({
   effort: z.looseObject({ level: z.string().optional() }).nullable().optional().catch(undefined),
 });
 
+/** subagentStatusLine stdin: base session fields plus one entry per active
+ *  subagent task (verified against the 2.1.214 bundle + docs 2026-07-18;
+ *  tasks[].model/contextWindowSize need claude >= 2.1.205, effort >= 2.1.214).
+ *  Same loose + catch degradation contract as StatusLineStdinSchema. */
+export const SubagentStatusLineStdinSchema = z.looseObject({
+  tasks: z
+    .array(
+      z.looseObject({
+        id: z.string().optional(),
+        name: z.string().nullable().optional().catch(undefined),
+        description: z.string().nullable().optional().catch(undefined),
+        label: z.string().nullable().optional().catch(undefined),
+        model: z.string().nullable().optional().catch(undefined),
+        effort: z.string().nullable().optional().catch(undefined),
+        contextWindowSize: z.number().nullable().optional().catch(undefined),
+        tokenCount: z.number().nullable().optional().catch(undefined),
+      }),
+    )
+    .optional()
+    .catch(undefined),
+});
+
 /** Success body of the OAuth refresh grant. */
 export const RefreshResponseSchema = z.looseObject({
   access_token: z.string(),

package/src/main.ts

@@ -6,6 +6,7 @@
 import { basename } from "node:path";
 import { runSupervisor } from "./entries/supervisor.ts";
 import { runStatusline } from "./entries/statusline.ts";
+import { runSubagentStatusline } from "./entries/subagentstatusline.ts";
 import { runStopHook } from "./entries/stophook.ts";
 import { runSessionStart } from "./entries/sessionstart.ts";
 import { cmdInit } from "./cli/init.ts";
@@ -25,6 +26,7 @@ import { cmdRename } from "./cli/rename.ts";
 import { cmdSwitch } from "./cli/switch.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
+import { cmdServe } from "./cli/serve.ts";
 import { uninstallSupervisor } from "./lib/install.ts";
 import { c } from "./cli/render.ts";
 
@@ -45,6 +47,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing status --force")}  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("xx --force")} works too
   ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120, never pings)
   ${c.cyan("tokenmaxxing config")} [get|set|unset|tidy]  inspect and edit config.json (bare = effective config with sources)
+  ${c.cyan("tokenmaxxing serve")} [setup|link|unlink|links]  Slack bridge daemon: mention the bot in a linked channel to open a claude session per thread (worktree by default)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} <sel>
@@ -72,6 +75,7 @@ async function main(): Promise<number> {
 
   switch (sub) {
     case "__statusline": return runStatusline();
+    case "__subagent-statusline": return runSubagentStatusline();
     case "__stop-hook": return runStopHook();
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
@@ -80,6 +84,7 @@ async function main(): Promise<number> {
     case "switch": return args[1] === "--codex" ? cmdCodexSwitch(args[2]) : cmdSwitch(args[1]);
     case "check": return cmdCheck();
     case "config": return cmdConfig(args.slice(1));
+    case "serve": return cmdServe(args.slice(1));
     case "init": return args.includes("--codex") ? cmdCodexInit() : cmdInit();
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();
     case "auth": return cmdAuth(args.slice(1));