tokenmaxxing 0.16.0 → 0.18.0

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/cli/switch.ts

@@ -43,7 +43,7 @@ export async function cmdSwitch(selector?: string): Promise<number> {
       try {
         await performSwap(target);
       } catch (e) {
-        if (e instanceof InvalidGrantError) { console.error(c.red(`${target.label}'s refresh token is dead - re-add it`)); return 1; }
+        if (e instanceof InvalidGrantError) { console.error(c.red(`${target.label}'s refresh token is dead - run \`tokenmaxxing auth ${target.label}\``)); return 1; }
         throw e;
       }
       console.log(`${c.green("↻")} switched to ${c.bold(target.label)}`);
@@ -86,7 +86,7 @@ export async function cmdSwitch(selector?: string): Promise<number> {
       // Either every account needs re-auth, or every account is blocked with no
       // recoverable bound (unparsed reset clocks AND no sample time - see log).
       const reauth = fresh.accounts.filter((a) => a.needsReauth).map((a) => a.label);
-      if (reauth.length > 0) { console.error(c.yellow(`no switchable account - re-auth needed: ${reauth.join(", ")}`)); return 1; }
+      if (reauth.length > 0) { console.error(c.yellow(`no switchable account - reauth needed (run \`tokenmaxxing auth --all\`): ${reauth.join(", ")}`)); return 1; }
       // never freeze a label drift behind a no-op (see header).
       if (drifted && active) return swapTo(active);
       console.log(c.yellow("all accounts at their limit with unknown reset times (unparsed reset clocks? see tokenmaxxing.log) - staying put"));

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),