tokenmaxxing 1.6.0 → 1.8.0

package/src/lib/slackstate.ts

@@ -1,352 +0,0 @@
-// `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.
-//
-// Retention tradeoff (intentional, closing-review critic gap): thread records
-// have NO age-out - the only GC is the model-invoked finish_thread close-out.
-// An abandoned thread's record persists indefinitely, ON PURPOSE: records are
-// tiny JSON, every record is a resumable conversation, and a time-based
-// reaper would silently kill threads the user still expects to revive with
-// one @mention. Revisit only if slack-threads/ ever measurably bloats.
-
-import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { omit } from "es-toolkit";
-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. */
-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(),
-  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-"),
-  /** the home workspace's team id (auth.test), the reference the external-author
-   *  guard compares message origins against; captured at setup and ensured at
-   *  daemon start, so it is only absent in configs saved before the guard. */
-  workspaceTeamId: z.string().optional(),
-  links: z.array(SlackLinkSchema).default([]),
-});
-export type SlackConfig = z.infer<typeof SlackConfigSchema>;
-
-/** Team-origin fields Slack stamps on message/mention event payloads. */
-const MessageOriginSchema = z.looseObject({
-  source_team: z.string().optional(),
-  team: z.string().optional(),
-  team_id: z.string().optional(),
-  user_team: z.string().optional(),
-});
-
-/** Outsiders must not drive sessions (owner rule 2026-07-16, ported from Slaude
- *  at its shutdown): in Slack Connect shared channels an external-workspace
- *  author carries team fields (`user_team` / `source_team` / `team`) that
- *  differ from the home workspace. Fail closed: reject a payload whose author
- *  origin is unreadable, absent, or disagrees on ANY present field. */
-export function isOutsideAuthor(input: { raw: unknown; workspaceTeamId: string }): boolean {
-  const parsed = MessageOriginSchema.safeParse(input.raw);
-  if (!parsed.success) return true;
-  const fields = [parsed.data.user_team, parsed.data.source_team, parsed.data.team, parsed.data.team_id]
-    .filter((team): team is string => team !== undefined);
-  if (fields.length === 0) return true;
-  return fields.some((team) => team !== input.workspaceTeamId);
-}
-
-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 -------------------------------------------
-
-/** Durable in-flight-turn marker. Written before a turn spawns and removed
- *  when it returns, so a marker that survives into the next daemon start means
- *  a restart killed the turn mid-run - startup then notifies the thread and
- *  auto-resumes it (2026-07-18 incident: a redeploy silently killed a ship
- *  turn 8 minutes in). A marker can also survive a RETURNED turn on purpose:
- *  a usage-limit deferral keeps it with resumeAt set, and the daemon resumes
- *  the turn itself once the pool recovers (2026-07-20 incident: limit-hit
- *  turns and depleted-pool drops sat dead until the user re-sent by hand).
- *  resumeCount caps the retries: every resumed attempt spends real quota, so
- *  a turn that keeps dying must not retry forever. */
-const ActiveTurnSchema = z.object({
-  /** the original folded prompt, replayed verbatim when the killed turn never
-   *  reached its init message (sessionId still null = nothing to resume). */
-  prompt: z.string(),
-  startedAt: z.string(),
-  resumeCount: z.number().int().nonnegative(),
-  /** epoch ms when the pool is expected usable again: present only on a
-   *  usage-limit deferral. The daemon resumes the turn at this time (or at
-   *  startup once it has passed); a still-depleted pool at the wake simply
-   *  re-defers, bounded by resumeCount. */
-  resumeAt: z.number().int().positive().optional(),
-  /** the DETACHED claude child's process-group id, persisted at spawn: an
-   *  uncatchable daemon death (SIGKILL, crash) skips the exit hook that kills
-   *  the group, so recovery must reap a surviving orphan before resuming -
-   *  two claude processes must never share the thread's cwd and session.
-   *  Absent until the spawn callback fires. */
-  pid: z.number().int().positive().optional(),
-  /** the ps lstart token captured for that pid at spawn: pid + start time is
-   *  the process identity, so recovery signals only a verified match - a
-   *  recycled pid must never get the kill (cubic review catch; this machine
-   *  runs the user's real claude sessions). Absent = identity unverifiable =
-   *  never signal. */
-  pidStartedAt: z.string().optional(),
-  /** Slack id (message ts) of the turn's triggering message: it carries the
-   *  status reactions (hourglass while running, check/x/question at settle),
-   *  so a recovered turn can finish the lifecycle it started. Absent for
-   *  turns whose trigger had no relayable message id (e.g. a resumed record
-   *  from before this field existed) - status reactions just skip then. */
-  messageId: z.string().optional(),
-  /** the triggering turn's requester ids: a recovered turn that flags
-   *  attention must persist the KILLED turn's actual askers, not whoever
-   *  authored the thread's newest message at recovery time (vercel review
-   *  catch on PR #43 - the wrong user would get nudged and answer-gated).
-   *  Absent on older records: recovery falls back to the streamable
-   *  handle's newest-author derivation. */
-  requesterIds: z.array(z.string()).optional(),
-  /** Slack ids of messages STEERED into this turn mid-run: they carry the
-   *  same hourglass-to-terminal reaction lifecycle as the triggering
-   *  message, so a killed or deferred turn's recovery must settle them too.
-   *  Their text is already folded into `prompt` at steer time, which is what
-   *  makes replays and retries include what the user steered in. An inbound
-   *  takeover of a DEFERRED turn also adopts the held turn's unsettled ids
-   *  here: the takeover serves their held prompt, and without the adoption
-   *  the old trigger's hourglass would read "processing" forever. */
-  steeredMessageIds: z.array(z.string()).optional(),
-});
-export type ActiveTurn = z.infer<typeof ActiveTurnSchema>;
-
-/** The thread is waiting on the user: set after a turn in which the model
- *  called need_attention (the ask-the-user flow), cleared when any relayable
- *  message or an asked user's reaction arrives. One nudge per ask: nudgedAt
- *  marks it spent, so the sweep can never mention-spam. */
-const ThreadAttentionSchema = z.object({
-  /** the asked users: only their reactions count as an answer. */
-  requesterIds: z.array(z.string()),
-  askedAt: z.string(),
-  nudgedAt: z.string().optional(),
-  /** the asking turn's triggering message: carries the question-mark status
-   *  reaction, removed once the user responds. */
-  messageId: z.string().optional(),
-});
-export type ThreadAttention = z.infer<typeof ThreadAttentionSchema>;
-
-/** A user reaction observed while no answer was owed: folded into the next
- *  turn's prompt as context (the model sees it and can respond), then
- *  cleared. Bounded to the newest few so an emoji burst cannot grow the
- *  record without bound. */
-const PendingReactionSchema = z.object({
-  userId: z.string(),
-  emoji: z.string(),
-  at: z.string(),
-});
-export type PendingReaction = z.infer<typeof PendingReactionSchema>;
-
-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; resume is cwd-keyed, so it
-   *  stays byte-stable for the thread's whole life (records from the removed
-   *  worktree-per-thread era pin their old worktree and keep working). */
-  cwd: z.string(),
-  /** claude session id; null until the first turn's init message arrives. */
-  sessionId: z.string().nullable(),
-  createdAt: z.string(),
-  /** present only while a turn is running (or was killed mid-run). */
-  activeTurn: ActiveTurnSchema.optional(),
-  /** present only while the thread waits on the user's answer. */
-  attention: ThreadAttentionSchema.optional(),
-  /** reactions observed since the last turn, folded into the next prompt. */
-  pendingReactions: z.array(PendingReactionSchema).optional(),
-});
-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");
-}
-
-/** Drop a finished thread's record: the thread-level GC (cleanupThread). */
-export function deleteSlackThread(threadId: string): void {
-  const f = threadFile(threadId);
-  if (existsSync(f)) unlinkSync(f);
-}
-
-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;
-}
-
-// ---- interrupted-turn resume decision (unit-tested) ------------------------
-
-/** Resumed attempts spend real quota, so an interrupted turn retries at most
- *  this many times before startup gives up and asks for a human message. */
-export const MAX_TURN_RESUMES = 3;
-
-const ResumeDecisionSchema = z.union([
-  z.object({ kind: z.literal("give-up"), notice: z.string() }),
-  z.object({
-    kind: z.literal("resume"),
-    notice: z.string(),
-    prompt: z.string(),
-    /** session to resume; null = the kill landed before init assigned one,
-     *  so the original prompt replays in a fresh session. */
-    sessionId: z.string().nullable(),
-    /** the incremented marker to persist BEFORE the resumed turn spawns, so
-     *  a kill during the resume still counts toward the cap. */
-    marker: ActiveTurnSchema,
-  }),
-]);
-export type ResumeDecision = z.infer<typeof ResumeDecisionSchema>;
-
-/** What to do with a thread whose activeTurn marker survived: either the
- *  previous daemon died mid-turn (no resumeAt - startup recovery) or a
- *  usage-limit deferral parked the turn (resumeAt set - the scheduler fires
- *  it once the pool recovers). Returns null for threads with no marker. The
- *  resumed marker drops resumeAt: the wake is consumed, and a still-depleted
- *  pool at the resume writes a fresh deferral with a fresh wake. */
-export function resumeDecision(record: SlackThread): ResumeDecision | null {
-  const turn = record.activeTurn;
-  if (!turn) return null;
-  const deferred = turn.resumeAt !== undefined;
-  if (turn.resumeCount >= MAX_TURN_RESUMES) {
-    return {
-      kind: "give-up",
-      notice: deferred
-        ? `this turn kept hitting the pool's usage limits and ${MAX_TURN_RESUMES} resume attempts were spent - giving up. Send a new message to continue.`
-        : `a daemon restart interrupted this turn, and ${MAX_TURN_RESUMES} resume attempts were interrupted too - giving up. Send a new message to continue.`,
-    };
-  }
-  const marker = omit({ ...turn, resumeCount: turn.resumeCount + 1 }, ["resumeAt"]);
-  const attempt = marker.resumeCount > 1 ? ` (attempt ${marker.resumeCount}/${MAX_TURN_RESUMES})` : "";
-  if (record.sessionId === null) {
-    return {
-      kind: "resume",
-      notice: deferred
-        ? `the account pool has recovered - running your held message${attempt}`
-        : `a daemon restart interrupted this turn before its session opened - starting it over${attempt}`,
-      prompt: turn.prompt,
-      sessionId: null,
-      marker,
-    };
-  }
-  return {
-    kind: "resume",
-    notice: deferred ? `the account pool has recovered - resuming this turn${attempt}` : `a daemon restart interrupted this turn - resuming${attempt}`,
-    prompt: deferred
-      ? `Your previous turn stopped early because every pooled account was at its usage limit; the pool has recovered. Pick up exactly where you left off and finish the task. If the work was already complete, just summarize the final state. The original request was:\n\n${turn.prompt}`
-      : `A tokenmaxxing serve daemon restart killed your previous turn mid-run. Pick up exactly where you left off and finish the task. If the work was already complete, just summarize the final state. The original request was:\n\n${turn.prompt}`,
-    sessionId: record.sessionId,
-    marker,
-  };
-}
-
-// ---- 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;
-}
-
-/** 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 OF THE BOT from message text. Two forms: raw
- * mrkdwn ("<@U0123> rest") and the bare form the Chat SDK's incoming
- * mrkdwn->markdown normalization produces ("@U0123 rest") - observed live
- * 2026-07-18 when a relayed prompt arrived starting with the bot's bare
- * "@U..." token. Only a
- * token whose id equals botUserId is stripped (review catch 2026-07-18:
- * handleTurn runs this over every subscribed message, so a follow-up starting
- * with a colleague's mention must keep it - the prompt would otherwise lose
- * who it is about). An unknown botUserId strips nothing: without the id we
- * cannot tell the bot's mention from anyone else's.
- */
-export function stripLeadingMention(input: { text: string; botUserId: string | null }): string {
-  const trimmed = input.text.trimStart();
-  if (input.botUserId === null) return input.text.trim();
-  if (trimmed.startsWith("<@")) {
-    const close = trimmed.indexOf(">");
-    if (close < 0) return input.text.trim();
-    const [id] = trimmed.slice(2, close).split("|");
-    if (id === input.botUserId) return trimmed.slice(close + 1).trim();
-    return input.text.trim();
-  }
-  if (trimmed.startsWith("@U") || trimmed.startsWith("@W")) {
-    let end = 1;
-    while (end < trimmed.length) {
-      const ch = trimmed[end] ?? "";
-      if ((ch >= "0" && ch <= "9") || (ch >= "A" && ch <= "Z")) end += 1;
-      else break;
-    }
-    const next = trimmed[end];
-    const atBoundary = next === undefined || next === " " || next === "\n" || next === "\t";
-    if (end - 1 >= 2 && atBoundary && trimmed.slice(1, end) === input.botUserId) return trimmed.slice(end).trim();
-  }
-  return input.text.trim();
-}

package/src/lib/slackstream.ts

@@ -1,300 +0,0 @@
-// 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. All task
-// cards in a turn group into ONE collapsible Slack plan block (user ask
-// 2026-07-20: "squash them into one dropdown"; the serve edge posts each turn
-// as a StreamingPlan with groupTasks "plan", superseding the 2026-07-18
-// separate-messages-around-tool-runs shape), so this mapper emits no segment
-// breaks: a turn is one streamed message. TodoWrite is special-cased into one
-// stable "Todos" checklist card per stream that updates in place as items
-// progress. 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 { truncate } from "es-toolkit/compat";
-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;
-/** Slack docs claim a 256-char cap on task_update chunks, yet 400/600-char
- *  card fields render fine (live-verified 2026-07-18). 600 is the largest
- *  size observed rendering; staying inside that envelope beats trusting an
- *  unverified bigger budget (a ~15-line checklist still fits). */
-const TODO_DETAILS_MAX = 600;
-
-/** Natural activity labels for tool cards (user ask 2026-07-18: these five raw
- *  names read awkwardly in Slack). Every other tool name renders verbatim; a
- *  Map keeps prototype keys like "toString" from shadowing the fallback. */
-const TOOL_TITLES = new Map([
-  ["TaskCreate", "Creating task"],
-  ["TaskUpdate", "Updating task"],
-  ["ToolSearch", "Loading tools"],
-  ["WebFetch", "Fetching page"],
-  ["WebSearch", "Searching the web"],
-]);
-
-export function toolCardTitle(name: string): string {
-  return TOOL_TITLES.get(name) ?? name;
-}
-
-/** 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", "todo"]),
-  id: z.string(),
-  title: z.string(),
-  /** accumulated thinking text or partial tool-input JSON. */
-  acc: z.string(),
-});
-type OpenBlock = z.infer<typeof OpenBlockSchema>;
-
-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()),
-  /** TodoWrite tool_use id -> stable checklist-card id: a successful result
-   *  is suppressed as noise, but a FAILED write must flip the card to error
-   *  (the optimistic checklist would otherwise claim a state that never took
-   *  effect). */
-  todoCards: z.record(z.string(), z.string()),
-  thinkingCount: z.number(),
-  /** non-whitespace reply text already streamed this turn: a later main text
-   *  block gets a "\n\n" separator, restoring the visual break the removed
-   *  per-tool message split used to provide (without it, post-tool prose
-   *  glues onto pre-tool prose and a block opening with "## " or a ```
-   *  fence loses its line-start position). */
-  textStreamed: z.boolean(),
-});
-export type StreamMapState = z.infer<typeof StreamMapStateSchema>;
-
-export function newStreamMapState(): StreamMapState {
-  return { open: {}, toolTitles: {}, todoCards: {}, thinkingCount: 0, textStreamed: false };
-}
-
-const StreamPartSchema = z.union([z.string(), z.custom<StreamChunk>()]);
-export type StreamPart = z.infer<typeof StreamPartSchema>;
-
-/** 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(value.data, { length: DETAILS_MAX });
-  }
-  const compact = JSON.stringify(parsed);
-  return compact === "{}" ? null : truncate(compact, { length: DETAILS_MAX });
-}
-
-const TodoItemSchema = z.object({
-  content: z.string(),
-  status: z.enum(["pending", "in_progress", "completed"]),
-  activeForm: z.string(),
-});
-const TodoListSchema = z.object({ todos: z.array(TodoItemSchema) });
-
-/** Same status iconography the Chat SDK's own Plan object renders with. */
-const TODO_ICONS = { completed: "✅", in_progress: "🔄", pending: "⬜" } as const;
-
-/** The stable checklist-card id: every TodoWrite in the same stream updates
- *  one card in place instead of stacking a new card per call. */
-function todoCardId(parent: string | null): string {
-  return parent === null ? "todos" : `todos-${parent}`;
-}
-
-/** Checklist text out of a TodoWrite input blob; null when empty or junk.
- *  The in-progress item shows its activeForm ("Running tests") so the card
- *  reads as live narration, not a static list. An empty todos list maps to
- *  null on purpose: claude clears the list only after everything completed,
- *  and skipping that update keeps the finished all-checked card visible
- *  instead of blanking it (intentional tradeoff, PR #5 review). */
-export function todoChecklist(rawJson: string): { text: string; allDone: boolean } | null {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(rawJson);
-  } catch {
-    return null;
-  }
-  const list = TodoListSchema.safeParse(parsed);
-  if (!list.success || list.data.todos.length === 0) return null;
-  const lines = list.data.todos.map((t) => {
-    const label = t.status === "in_progress" && t.activeForm !== "" ? t.activeForm : t.content;
-    return `${TODO_ICONS[t.status]} ${label}`;
-  });
-  return {
-    text: truncate(lines.join("\n"), { length: TODO_DETAILS_MAX }),
-    allDone: list.data.todos.every((t) => t.status === "completed"),
-  };
-}
-
-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(trimmed, { length: 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,
- * all of which Slack folds into the turn's single plan block). Subagent
- * events (parent_tool_use_id set) contribute their TOOL cards to that plan
- * (user ask 2026-07-18: subagent activity shows alongside tool calls) but
- * never reply text or thinking cards: a subagent runs inside a top-level Task
- * tool, so its churn decorates the turn 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 === "text" && isMain && state.textStreamed) {
-        // a new text block after streamed text opens on a fresh paragraph:
-        // the whole turn is one Slack message now, and without the break
-        // post-tool prose would glue onto pre-tool prose mid-line.
-        return ["\n\n"];
-      }
-      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;
-        if (name === "TodoWrite") {
-          // bookkeeping, not a real tool run: no card until the list arrives,
-          // and no toolTitles entry (its "Todos have been modified" success
-          // result is noise; failures still surface via todoCards below).
-          const cardId = todoCardId(message.parent_tool_use_id);
-          state.open[key] = { kind: "todo", id: cardId, title: "Todos", acc: "" };
-          state.todoCards[id] = cardId;
-          return [];
-        }
-        const title = toolCardTitle(name);
-        state.open[key] = { kind: "tool", id, title, acc: "" };
-        state.toolTitles[id] = title;
-        return [{ type: "task_update", id, title, status: "in_progress" }];
-      }
-      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 do not count: a text block carrying only
-        // "\n\n" must not earn the next block a doubled separator.
-        if (event.delta.text.trim() !== "") state.textStreamed = 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(open.acc.trim(), { length: DETAILS_MAX }) }];
-      }
-      if (open.kind === "todo") {
-        const list = todoChecklist(open.acc);
-        if (list === null) return [];
-        return [{ type: "task_update", id: open.id, title: open.title, status: list.allDone ? "complete" : "in_progress", details: list.text }];
-      }
-      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 todoCard = state.todoCards[parsed.data.tool_use_id];
-      if (todoCard !== undefined) {
-        if (parsed.data.is_error !== true) continue;
-        const output = resultText(parsed.data.content);
-        chunks.push({ type: "task_update", id: todoCard, title: "Todos", status: "error", ...(output ? { output } : {}) });
-        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 === "system" && message.subtype === "local_command_output") {
-    // Slash-command relay (user ask 2026-07-18): a leading-slash prompt runs
-    // as a claude slash command CLI-side, and a local command's output
-    // (/usage, /context, ...) arrives as a non-streamed assistant message
-    // plus result.result with num_turns 0 - relayThread's no-text fallback
-    // posts that (verified live on SDK 0.3.214 + claude 2.1.214, fresh and
-    // resumed). This subtype is the SDK's documented wire surface for the
-    // same output, so map it too: if a claude update flips the engine to
-    // emitting it, the output still posts, and having posted text suppresses
-    // the result fallback so it never double-posts.
-    if (message.content.trim() === "") return [];
-    const sep = state.textStreamed ? "\n\n" : "";
-    state.textStreamed = true;
-    return [sep + message.content];
-  }
-  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",
-      // is_error can ride subtype "success" (a mid-turn usage limit does),
-      // and that turn must not render as complete.
-      status: message.subtype === "success" && message.is_error !== true ? "complete" : "error",
-      details: [models, cost, secs].filter((p) => p !== "").join("  "),
-    }];
-  }
-  return [];
-}

package/src/serve-plugin/.claude-plugin/plugin.json

@@ -1,4 +0,0 @@
-{
-  "name": "tokenmaxxing",
-  "description": "Skills for Claude Code sessions relayed through tokenmaxxing serve (the Slack bridge)"
-}