tokenmaxxing 1.6.0 → 1.8.0

package/src/lib/relay/registry.ts

@@ -0,0 +1,175 @@
+// Per-session registry under $TOKENMAXXING_HOME/relay/sessions/<id>.json.
+// Per-session flock only (high churn); never a global relay lock for turns.
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { paths } from "../paths.ts";
+import { writeFileAtomic } from "../atomic.ts";
+import { withLock } from "../lock.ts";
+import { ClaudePermissionModeSchema, type ClaudePermissionMode } from "./modes.ts";
+import { loadRelayConfig, type RelayWorker } from "./config.ts";
+
+export const RelaySessionStateSchema = z.enum([
+  "idle",
+  "running",
+  "permission-needed",
+  "destroyed",
+]);
+export type RelaySessionState = z.infer<typeof RelaySessionStateSchema>;
+
+export const RelayRegistryEntrySchema = z.object({
+  sessionId: z.uuid(),
+  tmuxName: z.string().min(1),
+  worker: z.enum(["claude", "codex"]),
+  permissionMode: ClaudePermissionModeSchema,
+  cwd: z.string().min(1),
+  state: RelaySessionStateSchema,
+  createdAt: z.number().int().nonnegative(),
+  lastActiveAt: z.number().int().nonnegative(),
+  pendingRequestId: z.string().min(1).optional(),
+});
+export type RelayRegistryEntry = z.infer<typeof RelayRegistryEntrySchema>;
+
+export function relaySessionsDir(): string {
+  return join(paths.relayDir, "sessions");
+}
+
+export function relayLocksDir(): string {
+  return join(paths.relayDir, "locks");
+}
+
+export function relayTurnDoneDir(): string {
+  return join(paths.relayDir, "turn-done");
+}
+
+export function relayPendingDir(): string {
+  return join(paths.relayDir, "pending");
+}
+
+export function relayDecisionsDir(): string {
+  return join(paths.relayDir, "decisions");
+}
+
+export function sessionEntryPath(input: { sessionId: string }): string {
+  return join(relaySessionsDir(), `${input.sessionId}.json`);
+}
+
+export function sessionLockPath(input: { sessionId: string }): string {
+  return join(relayLocksDir(), input.sessionId);
+}
+
+export function turnDonePath(input: { sessionId: string }): string {
+  return join(relayTurnDoneDir(), input.sessionId);
+}
+
+export function pendingRequestPath(input: { sessionId: string; requestId: string }): string {
+  return join(relayPendingDir(), input.sessionId, `${input.requestId}.json`);
+}
+
+export function decisionPath(input: { sessionId: string; requestId: string }): string {
+  return join(relayDecisionsDir(), input.sessionId, `${input.requestId}.json`);
+}
+
+export function tmuxNameFor(input: { sessionId: string; prefix?: string }): string {
+  const prefix = input.prefix ?? loadRelayConfig().sessionPrefix;
+  return `${prefix}${input.sessionId}`;
+}
+
+export function newSessionId(): string {
+  return crypto.randomUUID();
+}
+
+export function readEntry(input: { sessionId: string }): RelayRegistryEntry | null {
+  const path = sessionEntryPath(input);
+  if (!existsSync(path)) return null;
+  return RelayRegistryEntrySchema.parse(JSON.parse(readFileSync(path, "utf8")));
+}
+
+export function writeEntry(input: { entry: RelayRegistryEntry }): void {
+  mkdirSync(relaySessionsDir(), { recursive: true });
+  writeFileAtomic(sessionEntryPath({ sessionId: input.entry.sessionId }), JSON.stringify(input.entry, null, 2) + "\n");
+}
+
+export function deleteEntry(input: { sessionId: string }): void {
+  rmSync(sessionEntryPath(input), { force: true });
+}
+
+export async function withSessionLock<T>(input: {
+  sessionId: string;
+  fn: () => Promise<T> | T;
+}): Promise<T> {
+  mkdirSync(relayLocksDir(), { recursive: true });
+  return withLock(sessionLockPath({ sessionId: input.sessionId }), input.fn);
+}
+
+export function listEntries(): RelayRegistryEntry[] {
+  const dir = relaySessionsDir();
+  if (!existsSync(dir)) return [];
+  const out: RelayRegistryEntry[] = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".json")) continue;
+    const path = join(dir, name);
+    try {
+      out.push(RelayRegistryEntrySchema.parse(JSON.parse(readFileSync(path, "utf8"))));
+    } catch {
+      // skip corrupt; gc can reap
+    }
+  }
+  return out;
+}
+
+export function createEntry(input: {
+  sessionId: string;
+  worker: RelayWorker;
+  permissionMode: ClaudePermissionMode;
+  cwd: string;
+  now?: number;
+}): RelayRegistryEntry {
+  const now = input.now ?? Date.now();
+  const entry = RelayRegistryEntrySchema.parse({
+    sessionId: input.sessionId,
+    tmuxName: tmuxNameFor({ sessionId: input.sessionId }),
+    worker: input.worker,
+    permissionMode: input.permissionMode,
+    cwd: input.cwd,
+    state: "idle",
+    createdAt: now,
+    lastActiveAt: now,
+  });
+  writeEntry({ entry });
+  return entry;
+}
+
+export function touchEntry(input: {
+  sessionId: string;
+  state?: RelaySessionState;
+  permissionMode?: ClaudePermissionMode;
+  pendingRequestId?: string | null;
+  now?: number;
+}): RelayRegistryEntry {
+  const prev = readEntry({ sessionId: input.sessionId });
+  if (prev == null) throw new Error(`relay session not found: ${input.sessionId}`);
+  const next = RelayRegistryEntrySchema.parse({
+    ...prev,
+    state: input.state ?? prev.state,
+    permissionMode: input.permissionMode ?? prev.permissionMode,
+    lastActiveAt: input.now ?? Date.now(),
+    pendingRequestId: input.pendingRequestId === null
+      ? undefined
+      : (input.pendingRequestId ?? prev.pendingRequestId),
+  });
+  writeEntry({ entry: next });
+  return next;
+}
+
+/** True when a registry entry exists for this relay session id. */
+export function registryHas(input: { sessionId: string }): boolean {
+  return readEntry(input) != null;
+}
+
+export function entryMtimeMs(input: { sessionId: string }): number | null {
+  const path = sessionEntryPath(input);
+  if (!existsSync(path)) return null;
+  return statSync(path).mtimeMs;
+}

package/src/lib/relay/tmux.ts

@@ -0,0 +1,109 @@
+// Thin tmux wrapper. Exact session names only; never pattern-kill. Injectable
+// for hermetic tests that must not require a real tmux server or workers.
+
+import { z } from "zod";
+
+export type TmuxBackend = {
+  hasSession: (input: { name: string }) => boolean;
+  newSession: (input: { name: string; cwd: string; command: string }) => void;
+  killSession: (input: { name: string }) => void;
+  sendKeys: (input: { name: string; text: string; enter?: boolean }) => void;
+  capturePane: (input: { name: string }) => string;
+  listSessions: () => string[];
+};
+
+function runTmux(args: string[]): { ok: boolean; stdout: string; stderr: string; code: number } {
+  const res = Bun.spawnSync(["tmux", ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+  return {
+    ok: res.exitCode === 0,
+    code: res.exitCode ?? 1,
+    stdout: res.stdout.toString(),
+    stderr: res.stderr.toString(),
+  };
+}
+
+export const liveTmux: TmuxBackend = {
+  hasSession: ({ name }) => runTmux(["has-session", "-t", name]).ok,
+  newSession: ({ name, cwd, command }) => {
+    const res = runTmux(["new-session", "-d", "-s", name, "-c", cwd, command]);
+    if (!res.ok) throw new Error(`tmux new-session failed for ${name}: ${res.stderr.trim() || res.stdout.trim()}`);
+  },
+  killSession: ({ name }) => {
+    // Exact name only. Missing session is success for destroy/gc idempotence.
+    runTmux(["kill-session", "-t", name]);
+  },
+  sendKeys: ({ name, text, enter = true }) => {
+    const res = runTmux(["send-keys", "-t", name, "-l", "--", text]);
+    if (!res.ok) throw new Error(`tmux send-keys failed for ${name}: ${res.stderr.trim()}`);
+    if (enter) {
+      const enterRes = runTmux(["send-keys", "-t", name, "Enter"]);
+      if (!enterRes.ok) throw new Error(`tmux send-keys Enter failed for ${name}: ${enterRes.stderr.trim()}`);
+    }
+  },
+  capturePane: ({ name }) => {
+    const res = runTmux(["capture-pane", "-p", "-t", name, "-S", "-200"]);
+    if (!res.ok) return "";
+    return res.stdout;
+  },
+  listSessions: () => {
+    const res = runTmux(["list-sessions", "-F", "#{session_name}"]);
+    if (!res.ok) return [];
+    return res.stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  },
+};
+
+let backend: TmuxBackend = liveTmux;
+
+export function getTmux(): TmuxBackend {
+  return backend;
+}
+
+/** Test-only: replace the tmux backend. */
+export function setTmuxBackend(input: { backend: TmuxBackend }): void {
+  backend = input.backend;
+}
+
+export function resetTmuxBackend(): void {
+  backend = liveTmux;
+}
+
+const MemorySessionSchema = z.object({
+  name: z.string(),
+  cwd: z.string(),
+  command: stringOrEmpty(),
+  keys: z.array(z.string()).default([]),
+  pane: z.string().default(""),
+});
+
+function stringOrEmpty() {
+  return z.string();
+}
+
+/** In-memory tmux for hermetic tests. */
+export function createMemoryTmux(): TmuxBackend & { sessions: Map<string, z.infer<typeof MemorySessionSchema>> } {
+  const sessions = new Map<string, z.infer<typeof MemorySessionSchema>>();
+  const api: TmuxBackend & { sessions: typeof sessions } = {
+    sessions,
+    hasSession: ({ name }) => sessions.has(name),
+    newSession: ({ name, cwd, command }) => {
+      if (sessions.has(name)) throw new Error(`tmux session already exists: ${name}`);
+      sessions.set(name, MemorySessionSchema.parse({ name, cwd, command, keys: [], pane: "" }));
+    },
+    killSession: ({ name }) => {
+      sessions.delete(name);
+    },
+    sendKeys: ({ name, text, enter = true }) => {
+      const s = sessions.get(name);
+      if (!s) throw new Error(`no tmux session: ${name}`);
+      s.keys.push(enter ? `${text}\n` : text);
+      s.pane += enter ? `${text}\n` : text;
+    },
+    capturePane: ({ name }) => sessions.get(name)?.pane ?? "",
+    listSessions: () => [...sessions.keys()],
+  };
+  return api;
+}

package/src/lib/relay/turn.ts

@@ -0,0 +1,137 @@
+// relay turn: ensure session, send prompt, wait until turn-done OR permission-needed.
+
+import { delay } from "es-toolkit";
+import { loadRelayConfig } from "./config.ts";
+import {
+  clearPendingRequest,
+  clearTurnDoneMarker,
+  listPendingRequests,
+  readTurnDoneMarker,
+} from "./markers.ts";
+import { permissionPingsEnabled, type ClaudePermissionMode } from "./modes.ts";
+import { formatRelayStdout, type RelayStdout } from "./protocol.ts";
+import { readEntry, touchEntry, withSessionLock } from "./registry.ts";
+import { getTmux } from "./tmux.ts";
+import { ensureSession, sendPrompt } from "./worker.ts";
+import type { RelayWorker } from "./config.ts";
+
+const POLL_MS = 50;
+
+export type TurnParams = {
+  sessionId?: string;
+  worker?: RelayWorker;
+  permissionMode?: ClaudePermissionMode;
+  cwd: string;
+  prompt?: string;
+  /** When true, do not send a prompt; only wait for the next marker. */
+  waitOnly?: boolean;
+  timeoutMs?: number;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+};
+
+export type TurnResult = {
+  exitCode: number;
+  stdout: string;
+  payload: RelayStdout;
+  entrySessionId: string;
+};
+
+export async function runTurn(input: TurnParams): Promise<TurnResult> {
+  const cfg = loadRelayConfig();
+  const sleep = input.sleep ?? delay;
+  const now = input.now ?? Date.now;
+  const timeoutMs = input.timeoutMs ?? cfg.turnTimeoutMs;
+
+  const entry = await ensureSession({
+    sessionId: input.sessionId,
+    worker: input.worker,
+    permissionMode: input.permissionMode,
+    cwd: input.cwd,
+    now: now(),
+  });
+
+  if (!input.waitOnly) {
+    const prompt = input.prompt ?? "";
+    if (prompt.trim() === "") throw new Error("relay turn requires a prompt (argv or stdin)");
+    await sendPrompt({ sessionId: entry.sessionId, prompt });
+  } else {
+    await withSessionLock({
+      sessionId: entry.sessionId,
+      fn: () => touchEntry({ sessionId: entry.sessionId, state: "running", now: now() }),
+    });
+  }
+
+  const deadline = now() + timeoutMs;
+  while (now() < deadline) {
+    const pending = listPendingRequests({ sessionId: entry.sessionId });
+    const live = readEntry({ sessionId: entry.sessionId });
+    const mode = live?.permissionMode ?? entry.permissionMode;
+    if (pending.length > 0 && permissionPingsEnabled({ mode })) {
+      const req = pending[0]!;
+      await withSessionLock({
+        sessionId: entry.sessionId,
+        fn: () => touchEntry({
+          sessionId: entry.sessionId,
+          state: "permission-needed",
+          pendingRequestId: req.requestId,
+          now: now(),
+        }),
+      });
+      const payload: RelayStdout = {
+        kind: "permission-needed",
+        sessionId: entry.sessionId,
+        permissionMode: mode,
+        requestId: req.requestId,
+        summary: req.summary,
+        detail: req.detail,
+      };
+      return {
+        exitCode: 0,
+        stdout: formatRelayStdout({ payload }),
+        payload,
+        entrySessionId: entry.sessionId,
+      };
+    }
+    // Under bypassPermissions, auto-clear any stray pending (should not fire).
+    if (pending.length > 0 && !permissionPingsEnabled({ mode })) {
+      for (const req of pending) {
+        clearPendingRequest({ sessionId: entry.sessionId, requestId: req.requestId });
+      }
+    }
+
+    const done = readTurnDoneMarker({ sessionId: entry.sessionId });
+    if (done != null) {
+      const text = getTmux().capturePane({ name: entry.tmuxName });
+      clearTurnDoneMarker({ sessionId: entry.sessionId });
+      await withSessionLock({
+        sessionId: entry.sessionId,
+        fn: () => touchEntry({
+          sessionId: entry.sessionId,
+          state: "idle",
+          pendingRequestId: null,
+          now: now(),
+        }),
+      });
+      const payload: RelayStdout = {
+        kind: "turn-done",
+        sessionId: entry.sessionId,
+        permissionMode: mode,
+        text,
+      };
+      return {
+        exitCode: 0,
+        stdout: formatRelayStdout({ payload }),
+        payload,
+        entrySessionId: entry.sessionId,
+      };
+    }
+
+    await sleep(POLL_MS);
+  }
+
+  throw new Error(`relay turn timed out after ${timeoutMs}ms (session ${entry.sessionId})`);
+}
+
+// re-export for callers that type worker from turn
+export type { RelayWorker };

package/src/lib/relay/worker.ts

@@ -0,0 +1,141 @@
+// Ensure a durable tmux worker for a relay session. Spawns tokenmaxxing-
+// supervised claude/codex via PATH shims with pooled env intact.
+
+import { join } from "node:path";
+import { paths } from "../paths.ts";
+import { claudeArgvForMode, codexArgvForMode, type ClaudePermissionMode } from "./modes.ts";
+import { loadRelayConfig, type RelayWorker } from "./config.ts";
+import {
+  createEntry,
+  readEntry,
+  touchEntry,
+  withSessionLock,
+  type RelayRegistryEntry,
+} from "./registry.ts";
+import { getTmux } from "./tmux.ts";
+import { clearTurnDoneMarker } from "./markers.ts";
+
+export const RELAY_SESSION_ENV = "TOKENMAXXING_RELAY_SESSION";
+
+function shellQuote(input: { value: string }): string {
+  return `'${input.value.replaceAll("'", `'\\''`)}'`;
+}
+
+export function buildWorkerCommand(input: {
+  sessionId: string;
+  worker: RelayWorker;
+  permissionMode: ClaudePermissionMode;
+  binDir?: string;
+}): string {
+  const binDir = input.binDir ?? paths.binDir;
+  // Keep $PATH expandable: only quote the binDir segment.
+  const envPrefix = `TOKENMAXXING_RELAY_SESSION=${shellQuote({ value: input.sessionId })} PATH=${shellQuote({ value: binDir })}:"$PATH"`;
+  if (input.worker === "claude") {
+    const modeArgs = claudeArgvForMode({ mode: input.permissionMode }).map((a) => shellQuote({ value: a })).join(" ");
+    // Interactive durable session pinned to the relay UUID as Claude session id.
+    return `${envPrefix} claude --session-id ${shellQuote({ value: input.sessionId })} ${modeArgs}`;
+  }
+  const modeArgs = codexArgvForMode({ mode: input.permissionMode }).map((a) => shellQuote({ value: a })).join(" ");
+  return `${envPrefix} codex ${modeArgs}`;
+}
+
+export async function ensureSession(input: {
+  sessionId?: string;
+  worker?: RelayWorker;
+  permissionMode?: ClaudePermissionMode;
+  cwd: string;
+  now?: number;
+}): Promise<RelayRegistryEntry> {
+  const cfg = loadRelayConfig();
+  const sessionId = input.sessionId ?? crypto.randomUUID();
+  const worker = input.worker ?? cfg.defaultWorker;
+  const permissionMode = input.permissionMode ?? cfg.defaultPermissionMode;
+
+  return withSessionLock({
+    sessionId,
+    fn: () => {
+      const existing = readEntry({ sessionId });
+      const tmux = getTmux();
+      if (existing != null) {
+        if (!tmux.hasSession({ name: existing.tmuxName })) {
+          const command = buildWorkerCommand({
+            sessionId,
+            worker: existing.worker,
+            permissionMode: input.permissionMode ?? existing.permissionMode,
+          });
+          tmux.newSession({ name: existing.tmuxName, cwd: existing.cwd, command });
+        }
+        return touchEntry({
+          sessionId,
+          permissionMode: input.permissionMode,
+          state: "idle",
+          now: input.now,
+        });
+      }
+      const entry = createEntry({
+        sessionId,
+        worker,
+        permissionMode,
+        cwd: input.cwd,
+        now: input.now,
+      });
+      const command = buildWorkerCommand({ sessionId, worker, permissionMode });
+      tmux.newSession({ name: entry.tmuxName, cwd: input.cwd, command });
+      return entry;
+    },
+  });
+}
+
+export async function sendPrompt(input: {
+  sessionId: string;
+  prompt: string;
+}): Promise<void> {
+  await withSessionLock({
+    sessionId: input.sessionId,
+    fn: () => {
+      const entry = readEntry({ sessionId: input.sessionId });
+      if (entry == null) throw new Error(`relay session not found: ${input.sessionId}`);
+      clearTurnDoneMarker({ sessionId: input.sessionId });
+      getTmux().sendKeys({ name: entry.tmuxName, text: input.prompt, enter: true });
+      touchEntry({ sessionId: input.sessionId, state: "running" });
+    },
+  });
+}
+
+export async function setLivePermissionMode(input: {
+  sessionId: string;
+  permissionMode: ClaudePermissionMode;
+}): Promise<RelayRegistryEntry> {
+  return withSessionLock({
+    sessionId: input.sessionId,
+    fn: () => {
+      const entry = readEntry({ sessionId: input.sessionId });
+      if (entry == null) throw new Error(`relay session not found: ${input.sessionId}`);
+      // Best-effort: cycle Claude's Shift+Tab equivalent via a slash command when
+      // the worker is Claude. Codex needs a respawn for sandbox changes.
+      if (entry.worker === "claude" && getTmux().hasSession({ name: entry.tmuxName })) {
+        getTmux().sendKeys({
+          name: entry.tmuxName,
+          text: `/permissions ${input.permissionMode}`,
+          enter: true,
+        });
+      } else if (entry.worker === "codex") {
+        getTmux().killSession({ name: entry.tmuxName });
+        const command = buildWorkerCommand({
+          sessionId: input.sessionId,
+          worker: "codex",
+          permissionMode: input.permissionMode,
+        });
+        getTmux().newSession({ name: entry.tmuxName, cwd: entry.cwd, command });
+      }
+      return touchEntry({
+        sessionId: input.sessionId,
+        permissionMode: input.permissionMode,
+      });
+    },
+  });
+}
+
+export function workerBinHint(): string {
+  return join(paths.binDir, "claude");
+}

package/src/lib/usage.ts

@@ -199,11 +199,12 @@ export function parseUsageLimitEpoch(input: { text: string }): number | null {
 
 /**
  * Persist a limit observed in a turn RESULT into usage.json so the next
- * decision sees the depleted account immediately. A headless serve/SDK process
- * has no statusLine tee and `loadFreshSnapshots` skips re-probing inside the
- * poll TTL (and `/usage` is fail-silent against the just-limited active token
- * anyway), so without this write a post-limit retry re-decides off the stale
- * pre-limit snapshot and respawns the same depleted account. The session
+ * decision sees the depleted account immediately. Callers without a statusLine
+ * tee (headless Agent SDK integrations) should invoke this on errored limit
+ * results: `loadFreshSnapshots` skips re-probing inside the poll TTL and
+ * `/usage` is fail-silent against the just-limited active token, so without
+ * this write a post-limit retry re-decides off the stale pre-limit snapshot
+ * and respawns the same depleted account. The session
  * window is stamped 100% with the announced reset: whichever window actually
  * tripped, the account is unusable until then, and the hard path swaps away.
  * `org` is the identity captured AT THE SPAWN BOUNDARY of the turn that

package/src/main.ts

@@ -3,9 +3,7 @@
 // `claude` (or `__supervise`), routes hook/statusLine subcommands, and otherwise
 // dispatches the `tokenmaxxing` CLI.
 
-import { existsSync } from "node:fs";
 import { basename } from "node:path";
-import { paths } from "./lib/paths.ts";
 import { runSupervisor } from "./entries/supervisor.ts";
 import { runStatusline } from "./entries/statusline.ts";
 import { runSubagentStatusline } from "./entries/subagentstatusline.ts";
@@ -29,7 +27,8 @@ 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 { cmdRelay } from "./cli/relay.ts";
+import { runRelayPermissionHook } from "./entries/relaypermission.ts";
 import { timerDeactivationHint, uninstallSupervisor } from "./lib/install.ts";
 import { c } from "./cli/render.ts";
 
@@ -50,7 +49,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 in the repo checkout
+  ${c.cyan("tokenmaxxing relay")} …  durable tmux relay for host agents (turn/decide/status/…); see ${c.cyan("relay --help")}
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} [--codex] <sel>
@@ -104,18 +103,19 @@ async function main(): Promise<number> {
     case "__stop-hook": return runStopHook();
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
+    case "__relay-permission-hook": return runRelayPermissionHook();
     case undefined: return cmdStatus(); // bare `tokenmaxxing` / `xx` → status
     case "--force": return cmdStatus(true); // bare `xx --force` → status --force
     // --codex accepted anywhere, like init/add/status: the old args[1]-only
     // check made `xx switch <sel> --codex` silently run a real CLAUDE swap
     // (one email can hold both pools' accounts - closing-review catch).
+    case "relay": return cmdRelay(args.slice(1));
     case "switch": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
       return args.includes("--codex") ? cmdCodexSwitch(rest[0]) : cmdSwitch(rest[0]);
     }
     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));
@@ -145,7 +145,7 @@ async function main(): Promise<number> {
       console.log(`removed ${removed.join(", ")}`);
       if (!out.timerDeactivated) console.log(c.yellow(`⚠ the check job may still be loaded - run: ${timerDeactivationHint()}`));
       if (!out.pathLineRemoved) console.log(c.dim("(no tokenmaxxing PATH line found in the shell rc)"));
-      console.log(`kept: accounts.json, config.json${existsSync(paths.slackJson) ? ", slack.json (Slack tokens)" : ""}, and every parked credential (claude - macOS: keychain items, Linux: creds/; codex: codex-creds/) - remove accounts with \`xx rm\` to delete their credentials`);
+      console.log(`kept: accounts.json, config.json, and every parked credential (claude - macOS: keychain items, Linux: creds/; codex: codex-creds/) - remove accounts with \`xx rm\` to delete their credentials`);
       return 0;
     }
     case "help":