tokenmaxxing 0.19.1 → 0.21.0

package/src/lib/slackstate.ts

@@ -4,8 +4,15 @@
 // 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 } from "node:fs";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.ts";
@@ -14,15 +21,13 @@ 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"]);
+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(),
@@ -32,10 +37,36 @@ 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")));
@@ -55,15 +86,46 @@ export function isChannelId(s: string): boolean {
 
 // ---- 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). 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(),
+  /** 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(),
+});
+export type ActiveTurn = z.infer<typeof ActiveTurnSchema>;
+
 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). */
+  /** 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(),
 });
 export type SlackThread = z.infer<typeof SlackThreadSchema>;
 
@@ -88,6 +150,12 @@ 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[] = [];
@@ -98,6 +166,59 @@ export function listSlackThreads(): SlackThread[] {
   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 startup should do with a thread whose activeTurn marker survived the
+ *  previous daemon. Returns null for threads with no surviving marker. */
+export function resumeDecision(record: SlackThread): ResumeDecision | null {
+  const turn = record.activeTurn;
+  if (!turn) return null;
+  if (turn.resumeCount >= MAX_TURN_RESUMES) {
+    return {
+      kind: "give-up",
+      notice: `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 = { ...turn, resumeCount: turn.resumeCount + 1 };
+  const attempt = marker.resumeCount > 1 ? ` (attempt ${marker.resumeCount}/${MAX_TURN_RESUMES})` : "";
+  if (record.sessionId === null) {
+    return {
+      kind: "resume",
+      notice: `a daemon restart interrupted this turn before its session opened - starting it over${attempt}`,
+      prompt: turn.prompt,
+      sessionId: null,
+      marker,
+    };
+  }
+  return {
+    kind: "resume",
+    notice: `a daemon restart interrupted this turn - resuming${attempt}`,
+    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 {
@@ -121,11 +242,37 @@ export function bareChannelId(id: string): string {
   return id.startsWith("slack:") ? id.slice("slack:".length) : id;
 }
 
-/** Strip a leading Slack mention token ("<@U0123> rest") from message text. */
-export function stripLeadingMention(text: string): string {
-  const trimmed = text.trimStart();
-  if (!trimmed.startsWith("<@")) return text.trim();
-  const close = trimmed.indexOf(">");
-  if (close < 0) return text.trim();
-  return trimmed.slice(close + 1).trim();
+/**
+ * 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 "@U0BHS1YKNSK". 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,22 +1,45 @@
 // Maps Claude Agent SDK messages onto Chat SDK stream chunks so a relayed
 // Slack turn shows the agent's process natively: task cards for thinking and
 // tool calls (pending -> in_progress -> complete/error), streamed text via
-// markdown_text, and a closing turn card with model/cost/duration. Structured
-// chunks render only when the Slack app has the agent feature + assistant:write
-// (the adapter drops them gracefully otherwise); plain text streams either way.
+// markdown_text, and a closing turn card with model/cost/duration. 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"]),
+  kind: z.enum(["thinking", "tool", "todo"]),
   id: z.string(),
   title: z.string(),
   /** accumulated thinking text or partial tool-input JSON. */
@@ -24,11 +47,16 @@ const OpenBlockSchema = z.object({
 });
 type OpenBlock = z.infer<typeof OpenBlockSchema>;
 
-export const StreamMapStateSchema = z.object({
+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(),
   /** reply text streamed since the last segment break. */
   textSinceBreak: z.boolean(),
@@ -36,22 +64,17 @@ export const StreamMapStateSchema = z.object({
 export type StreamMapState = z.infer<typeof StreamMapStateSchema>;
 
 export function newStreamMapState(): StreamMapState {
-  return { open: {}, toolTitles: {}, thinkingCount: 0, textSinceBreak: false };
+  return { open: {}, toolTitles: {}, todoCards: {}, thinkingCount: 0, textSinceBreak: false };
 }
 
 /** Emitted when a tool starts after streamed reply text: the bridge closes the
  *  current Slack message there and posts the rest as a new one, mirroring how
  *  an agent turn reads as separate messages around its tool runs. */
 export const SegmentBreakSchema = z.object({ type: z.literal("segment_break") });
-export type SegmentBreak = z.infer<typeof SegmentBreakSchema>;
 
-export const StreamPartSchema = z.union([z.string(), z.custom<StreamChunk>(), SegmentBreakSchema]);
+const StreamPartSchema = z.union([z.string(), z.custom<StreamChunk>(), SegmentBreakSchema]);
 export type StreamPart = z.infer<typeof StreamPartSchema>;
 
-function truncate(input: { text: string; max: number }): string {
-  return input.text.length > input.max ? `${input.text.slice(0, input.max)}...` : input.text;
-}
-
 /** One human line out of a tool-input JSON blob; null when nothing fits. */
 export function toolInputSummary(rawJson: string): string | null {
   let parsed: unknown;
@@ -64,10 +87,51 @@ export function toolInputSummary(rawJson: string): string | null {
   if (!obj.success) return null;
   for (const field of SUMMARY_FIELDS) {
     const value = z.string().min(1).safeParse(obj.data[field]);
-    if (value.success) return truncate({ text: value.data, max: DETAILS_MAX });
+    if (value.success) return truncate(value.data, { length: DETAILS_MAX });
   }
   const compact = JSON.stringify(parsed);
-  return compact === "{}" ? null : truncate({ text: compact, max: DETAILS_MAX });
+  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({
@@ -90,7 +154,7 @@ function resultText(content: z.infer<typeof ToolResultBlockSchema>["content"]):
         .join("\n")
     : content;
   const trimmed = joined.trim();
-  return trimmed === "" ? undefined : truncate({ text: trimmed, max: OUTPUT_MAX });
+  return trimmed === "" ? undefined : truncate(trimmed, { length: OUTPUT_MAX });
 }
 
 /**
@@ -118,9 +182,20 @@ export function agentEventChunks(input: { state: StreamMapState; message: SDKMes
       }
       if (event.content_block.type === "tool_use") {
         const { id, name } = event.content_block;
-        state.open[key] = { kind: "tool", id, title: name, acc: "" };
-        state.toolTitles[id] = name;
-        const card: StreamPart = { type: "task_update", id, title: name, status: "in_progress" };
+        if (name === "TodoWrite") {
+          // bookkeeping, not a real tool run: no card until the list arrives,
+          // no segment break, 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;
+        const card: StreamPart = { type: "task_update", id, title, status: "in_progress" };
         if (isMain && state.textSinceBreak) {
           state.textSinceBreak = false;
           return [{ type: "segment_break" }, card];
@@ -149,7 +224,12 @@ export function agentEventChunks(input: { state: StreamMapState; message: SDKMes
       if (!open) return [];
       delete state.open[key];
       if (open.kind === "thinking") {
-        return [{ type: "task_update", id: open.id, title: open.title, status: "complete", details: truncate({ text: open.acc.trim(), max: DETAILS_MAX }) }];
+        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 } : {}) }];
@@ -163,6 +243,13 @@ export function agentEventChunks(input: { state: StreamMapState; message: SDKMes
     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);
@@ -176,6 +263,20 @@ export function agentEventChunks(input: { state: StreamMapState; message: SDKMes
     }
     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 [];
+    state.textSinceBreak = true;
+    return [message.content];
+  }
   if (message.type === "result") {
     const models = Object.keys(message.modelUsage).join(" ");
     const cost = `$${message.total_cost_usd.toFixed(4)}`;
@@ -184,7 +285,9 @@ export function agentEventChunks(input: { state: StreamMapState; message: SDKMes
       type: "task_update",
       id: "turn",
       title: "Turn",
-      status: message.subtype === "success" ? "complete" : "error",
+      // 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("  "),
     }];
   }