@kolisachint/hoobot 0.0.3

package/.env.example

@@ -0,0 +1,46 @@
+# Copy to .env and fill in. Never commit .env.
+
+# Developer portal → your app → Bot → Reset Token
+DISCORD_TOKEN=
+
+# Comma-separated Discord user IDs allowed to use the bot.
+# Required: the bot refuses to start without it.
+ALLOWED_USER_IDS=758289752645959720
+
+# Only answer in the Hoo server.
+GUILD_ID=1554149385623838922
+
+# Optional: only answer in these channel IDs (comma-separated). Empty = all.
+CHANNEL_IDS=
+
+# Folder hoocode works in. Default: ./workspace
+HOO_WORKDIR=./workspace
+
+# Which Codex app-server to talk to. Empty = start `hoocode app-server`
+# in HOO_WORKDIR over stdio. Or a running server:
+#   unix://                         (not supported here; give the full path)
+#   unix:///Users/you/.cortexcode/app-server-control/app-server-control.sock
+#   stdio:codex app-server          (the real Codex, for comparison)
+APP_SERVER=
+
+# hoocode command, and extra flags for `hoocode app-server`
+# (only used when APP_SERVER is empty).
+HOOCODE_BIN=hoocode
+HOOCODE_ARGS=
+
+# Optional model for new threads, e.g. anthropic/claude-sonnet-4-5
+MODEL=
+
+# Discord thread -> app-server thread links.
+# Default: ~/.local/share/hoobot/links.json
+LINKS_FILE=
+
+# Minutes to wait for an Allow/Deny click before cancelling.
+APPROVAL_TIMEOUT_MINUTES=10
+
+# Minutes of silence before the bot lets go of a thread.
+# The conversation is saved by the server and resumes on the next message.
+IDLE_TIMEOUT_MINUTES=30
+
+# 1 = print hoocode's stderr to the terminal
+DEBUG=0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sachin Koli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# hoo-discord-bot
+
+Use **hoocode** from Discord.
+
+```
+Discord  ⇄  this bot (Bun + discord.js)  ⇄  Codex app-server protocol  ⇄  hoocode app-server
+```
+
+Each Discord thread is one app-server thread. The bot speaks only standard
+Codex app-server methods, so the server is swappable: `hoocode app-server`
+(default), or the real `codex app-server`, set with `APP_SERVER` in `.env`.
+By default the bot starts `hoocode app-server` itself, in `HOO_WORKDIR`.
+
+To share threads with other clients (e.g. the Codex TUI with
+`codex --remote unix://PATH`), run one server and point everyone at it:
+
+```sh
+cd workspace && hoocode app-server --listen unix://   # prints the socket path
+# .env: APP_SERVER=unix:///Users/you/.cortexcode/app-server-control/app-server-control.sock
+```
+
+## Install from npm
+
+Needs [Bun](https://bun.sh). The bot reads `.env` from the folder you start it in.
+
+```sh
+bun add -g @kolisachint/hoobot
+curl -o .env https://raw.githubusercontent.com/kolisachint/hoobot/main/.env.example   # then fill it in
+hoo-discord-bot
+```
+
+## Setup
+
+1. Install dependencies:
+
+   ```sh
+   bun install
+   ```
+
+2. Create your settings file:
+
+   ```sh
+   cp .env.example .env
+   ```
+
+3. Open `.env` and paste the bot token after `DISCORD_TOKEN=`.
+
+4. In the developer portal, on the **Bot** page,
+   turn on **Message Content Intent**.
+
+5. Start the bot:
+
+   ```sh
+   bun start
+   ```
+
+   You should see `Logged in as hoo#1234`.
+
+## Run in the background (macOS)
+
+Runs at login and restarts itself if it crashes.
+
+```sh
+scripts/service.sh install     # start + enable at login
+scripts/service.sh status      # running? pid?
+scripts/service.sh logs        # follow the log
+scripts/service.sh restart     # after editing .env or code
+scripts/service.sh uninstall   # stop + remove
+```
+
+- Service file: `~/Library/LaunchAgents/com.hoo.discord-bot.plist`
+- Log: `~/.local/state/hoo-discord-bot/bot.log`
+
+The Mac must be awake and logged in for the bot to answer.
+
+## Using it
+
+- **Start:** in any channel, mention the bot with a request,
+  e.g. `@hoo list the files here`. It opens a thread.
+- **Continue:** type in that thread. No mention needed.
+- **Steer:** typing while it's busy redirects the current run.
+
+### Commands (inside a thread)
+
+| Command | What it does |
+|---|---|
+| `!stop` | Stop the current run |
+| `!new` | Forget the conversation |
+| `!status` | Model, busy or not, thread, server |
+| `!model <name>` | Switch model from the next message |
+| `!help` | Show help |
+
+## Safety
+
+- Only user IDs in `ALLOWED_USER_IDS` can use it.
+  The bot won't start if that list is empty.
+- `bash`, `edit` and `write` show **Allow once / Deny** buttons.
+  No click within 10 minutes means denied.
+- There is no "Always" button. It would change your
+  global `~/.hoocode/hoo-config.json`.
+
+How the approvals work: on first start the bot writes
+`workspace/.cortexcode/hoo-config.json`, which puts that folder in a
+custom `discord` mode. In that mode only `read` runs without asking.
+Your normal `build` mode, which skips approvals, is not used here.
+The server sends approvals to every client on the thread; the first
+answer wins and the other clients see it resolved.
+
+## Files
+
+| Path | Purpose |
+|---|---|
+| `src/index.ts` | Discord side: mentions, threads, commands |
+| `src/session.ts` | One app-server thread per Discord thread; notifications → messages, buttons → approvals |
+| `src/codex-client.ts` | Codex app-server client (`unix://` WebSocket or `stdio:`) |
+| `src/links.ts` | Discord thread → app-server thread links (`LINKS_FILE`) |
+| `src/format.ts` | Splits long replies to fit Discord's 2000-character limit |
+| `workspace/` | hoocode's working folder (git-ignored); sessions are saved by hoocode |
+
+## Tests
+
+```sh
+bun run test                # message splitting (what CI runs)
+bun test/session.e2e.ts     # real app-server, fake Discord (uses API credits)
+APP_SERVER="stdio:codex app-server" bun test/session.e2e.ts   # same, real Codex
+bun run typecheck
+bun run check               # typecheck + unit tests
+```
+
+## Releasing
+
+Releases are driven by PR labels. `package.json`'s `version` is owned by CI;
+don't edit it by hand.
+
+| Label | On merge |
+|---|---|
+| `npm:patch` | 0.1.0 → 0.1.1 |
+| `npm:minor` | 0.1.0 → 0.2.0 |
+| `npm:major` | 0.1.0 → 1.0.0 |
+| none | no release |
+
+- `.github/workflows/ci.yml`: typecheck, unit tests and `npm pack --dry-run`
+  on every PR and on `main`.
+- `.github/workflows/pr-labels.yml`: fails a PR with more than one `npm:*`
+  label.
+- `.github/workflows/release.yml`: on merge to `main`, reads the merged PR's
+  label, bumps `package.json`, pushes `chore(release): vX.Y.Z` plus the tag
+  `vX.Y.Z` to `main`, creates the GitHub release, publishes to npm
+  (`NPM_TOKEN` secret) and comments on the PR. It can also be run by hand
+  (Actions → Release → Run workflow, pick a bump).
+
+Workflow:
+
+1. `/pr minor` (or `patch` / `major`; plain `/pr` for no release): branches,
+   runs `bun run check`, commits everything, pushes, opens the PR and
+   labels it `npm:minor`.
+2. Merge the PR on GitHub.
+3. `/postmerge`: waits for the release workflow, checks the tag, GitHub
+   release and npm version, then switches to `main`, pulls and deletes the
+   merged branch.
+
+The commands live in `.cortexcode/prompts/`. `NPM_TOKEN` must be an npm
+*Automation* (or granular publish) token. The bot pushes the release commit
+straight to `main`, so if you add branch protection, let GitHub Actions
+bypass it. If a release half-fails, re-run it: the release commit records
+`Release-PR: #N`, so a re-run finishes that version instead of bumping again.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@kolisachint/hoobot",
+  "version": "0.0.3",
+  "description": "Use hoocode from Discord: a Discord bot that talks the Codex app-server protocol",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kolisachint/hoobot.git"
+  },
+  "bugs": "https://github.com/kolisachint/hoobot/issues",
+  "homepage": "https://github.com/kolisachint/hoobot#readme",
+  "bin": {
+    "hoo-discord-bot": "src/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "engines": {
+    "bun": ">=1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.2",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "discord.js": "^14.27.0"
+  },
+  "scripts": {
+    "start": "bun src/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test test/format.test.ts test/codex-client.test.ts",
+    "check": "bun run typecheck && bun run test"
+  }
+}

package/src/codex-client.ts

@@ -0,0 +1,213 @@
+/**
+ * Client for a Codex app-server: `hoocode app-server` or the real
+ * `codex app-server`. Uses only standard Codex methods, so either works.
+ *
+ * Transports:
+ * - `unix://PATH`: WebSocket over a Unix socket (one JSON message per frame);
+ * - `stdio:CMD ARGS...`: spawn a server and talk LF-delimited JSON on its pipes.
+ */
+import { EventEmitter } from "node:events";
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { createInterface } from "node:readline";
+
+export type RequestId = number | string;
+
+export type Notification = { method: string; params: any };
+export type ServerRequest = { id: RequestId; method: string; params: any };
+
+export class RpcError extends Error {
+  constructor(
+    readonly code: number,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+interface Transport {
+  send(message: unknown): void;
+  close(): void;
+}
+
+/**
+ * Events: `notification` (Notification), `request` (ServerRequest),
+ * `close` (reason: string).
+ */
+export class CodexClient extends EventEmitter {
+  private nextId = 1;
+  private pending = new Map<RequestId, { resolve: (v: any) => void; reject: (e: Error) => void }>();
+  private transport: Transport | null = null;
+  private closed = false;
+
+  private constructor(readonly endpoint: string) {
+    super();
+  }
+
+  /**
+   * Connect and run the `initialize` handshake. Fails after
+   * `initializeTimeoutMs` if the server never answers (e.g. a hoocode
+   * build without `app-server`, which just sits on stdin).
+   */
+  static async connect(
+    endpoint: string,
+    clientInfo = { name: "hoobot", version: "0.1.0" },
+    options: { cwd?: string; initializeTimeoutMs?: number } = {},
+  ): Promise<CodexClient> {
+    const client = new CodexClient(endpoint);
+    await client.open(options.cwd);
+    const timeoutMs = options.initializeTimeoutMs ?? 15_000;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      await Promise.race([
+        client.request("initialize", {
+          clientInfo,
+          capabilities: { experimentalApi: true },
+        }),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () =>
+              reject(
+                new Error(
+                  `app-server at ${endpoint} did not answer initialize within ${timeoutMs / 1000}s. ` +
+                    "Does this hoocode build support `app-server`? Set HOOCODE_BIN or APP_SERVER in .env.",
+                ),
+              ),
+            timeoutMs,
+          );
+        }),
+      ]);
+    } catch (err) {
+      client.close();
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+    client.notify("initialized");
+    return client;
+  }
+
+  /** `cwd`: working folder for a `stdio:` server. */
+  private async open(cwd?: string) {
+    const onMessage = (text: string) => this.dispatch(text);
+    const onClose = (reason: string) => this.shutdown(reason);
+    if (this.endpoint.startsWith("unix://")) {
+      this.transport = await openUnix(this.endpoint.slice("unix://".length), onMessage, onClose);
+    } else if (this.endpoint.startsWith("stdio:")) {
+      const [cmd, ...args] = this.endpoint.slice("stdio:".length).trim().split(/\s+/);
+      if (!cmd) throw new Error("stdio: endpoint needs a command");
+      this.transport = openStdio(cmd, args, cwd, onMessage, onClose);
+    } else {
+      throw new Error(`unsupported endpoint ${this.endpoint} (use unix://PATH or stdio:CMD)`);
+    }
+  }
+
+  request<T = any>(method: string, params?: unknown): Promise<T> {
+    if (this.closed || !this.transport) return Promise.reject(new Error("app-server connection closed"));
+    const id = this.nextId++;
+    return new Promise<T>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.transport!.send(params === undefined ? { id, method } : { id, method, params });
+    });
+  }
+
+  notify(method: string, params?: unknown) {
+    this.transport?.send(params === undefined ? { method } : { method, params });
+  }
+
+  /** Answer a server request (e.g. an approval). */
+  respond(id: RequestId, result: unknown) {
+    this.transport?.send({ id, result });
+  }
+
+  close() {
+    this.transport?.close();
+    this.shutdown("closed by client");
+  }
+
+  get isClosed() {
+    return this.closed;
+  }
+
+  private dispatch(text: string) {
+    let msg: any;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (typeof msg?.method === "string") {
+      if (msg.id !== undefined && msg.id !== null) {
+        this.emit("request", { id: msg.id, method: msg.method, params: msg.params } satisfies ServerRequest);
+      } else {
+        this.emit("notification", { method: msg.method, params: msg.params } satisfies Notification);
+      }
+      return;
+    }
+    const waiter = this.pending.get(msg?.id);
+    if (!waiter) return;
+    this.pending.delete(msg.id);
+    if (msg.error) waiter.reject(new RpcError(msg.error.code ?? -1, msg.error.message ?? "error"));
+    else waiter.resolve(msg.result);
+  }
+
+  private shutdown(reason: string) {
+    if (this.closed) return;
+    this.closed = true;
+    for (const w of this.pending.values()) w.reject(new Error(`app-server connection closed: ${reason}`));
+    this.pending.clear();
+    this.emit("close", reason);
+  }
+}
+
+function openUnix(
+  path: string,
+  onMessage: (text: string) => void,
+  onClose: (reason: string) => void,
+): Promise<Transport> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket("ws+unix://" + path);
+    let opened = false;
+    ws.onopen = () => {
+      opened = true;
+      resolve({
+        send: (m) => ws.send(JSON.stringify(m)),
+        close: () => ws.close(),
+      });
+    };
+    ws.onmessage = (e) => onMessage(typeof e.data === "string" ? e.data : String(e.data));
+    ws.onerror = () => {
+      if (!opened) reject(new Error(`cannot connect to app-server at ${path}`));
+    };
+    ws.onclose = () => onClose("socket closed");
+  });
+}
+
+function openStdio(
+  cmd: string,
+  args: string[],
+  cwd: string | undefined,
+  onMessage: (text: string) => void,
+  onClose: (reason: string) => void,
+): Transport {
+  const child: ChildProcessWithoutNullStreams = spawn(cmd, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+  createInterface({ input: child.stdout }).on("line", (line) => {
+    if (line.trim()) onMessage(line);
+  });
+  child.stderr.on("data", (d) => {
+    if (process.env.DEBUG === "1") process.stderr.write(`[app-server] ${d}`);
+  });
+  child.on("exit", (code) => onClose(`app-server exited (${code})`));
+  child.on("error", (err) => onClose(err.message));
+  return {
+    send: (m) => child.stdin.write(JSON.stringify(m) + "\n"),
+    close: () => child.kill(),
+  };
+}
+
+/** Text input for `turn/start` / `turn/steer`, plus images as data URLs. */
+export function userInput(text: string, images: { data: string; mimeType: string }[] = []) {
+  const input: any[] = [];
+  if (text) input.push({ type: "text", text, text_elements: [] });
+  for (const img of images) input.push({ type: "image", url: `data:${img.mimeType};base64,${img.data}` });
+  return input;
+}

package/src/config.ts

@@ -0,0 +1,108 @@
+import { mkdirSync, existsSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+function required(name: string): string {
+  const value = process.env[name]?.trim();
+  if (!value) {
+    console.error(`Missing ${name}. Copy .env.example to .env and fill it in.`);
+    process.exit(1);
+  }
+  return value;
+}
+
+function list(name: string): string[] {
+  return (process.env[name] ?? "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export const config = {
+  token: required("DISCORD_TOKEN"),
+  /** Only these Discord user IDs can talk to the bot or approve tools. */
+  allowedUserIds: new Set(list("ALLOWED_USER_IDS")),
+  /** Optional: restrict to one server / some channels. */
+  guildId: process.env.GUILD_ID?.trim() || undefined,
+  channelIds: new Set(list("CHANNEL_IDS")),
+  /** Directory hoocode works in. */
+  workdir: resolve(process.env.HOO_WORKDIR?.trim() || "./workspace"),
+  hoocodeBin: process.env.HOOCODE_BIN?.trim() || "hoocode",
+  hoocodeArgs: (process.env.HOOCODE_ARGS ?? "").split(/\s+/).filter(Boolean),
+  /**
+   * The Codex app-server to talk to: `unix://PATH` for a running server
+   * (`hoocode app-server --listen unix://` or `codex app-server --listen unix://`),
+   * or empty to start `hoocode app-server` in the work folder over stdio.
+   */
+  appServer: process.env.APP_SERVER?.trim() || "",
+  /** Optional model for new threads, e.g. anthropic/claude-sonnet-4-5. */
+  model: process.env.MODEL?.trim() || undefined,
+  /** Discord thread → app-server thread links. */
+  linksFile: resolve(
+    process.env.LINKS_FILE?.trim() || join(homedir(), ".local", "share", "hoobot", "links.json"),
+  ),
+  approvalTimeoutMs: Number(process.env.APPROVAL_TIMEOUT_MINUTES ?? 10) * 60_000,
+  idleTimeoutMs: Number(process.env.IDLE_TIMEOUT_MINUTES ?? 30) * 60_000,
+  debug: process.env.DEBUG === "1",
+};
+
+if (config.allowedUserIds.size === 0) {
+  console.error(
+    "ALLOWED_USER_IDS is empty. Refusing to start: anyone in the server could run shell commands.",
+  );
+  process.exit(1);
+}
+
+/**
+ * Give the workspace a project-level hoocode config that puts it in a custom
+ * "discord" mode. Your global config auto-allows bash/edit/write in build mode,
+ * and project configs can only *add* to auto_allow for an existing mode, so a
+ * separate mode name is the only way to make hoocode ask first. Those asks
+ * become Allow / Deny buttons in Discord.
+ *
+ * Rust hoocode reads `<workspace>/.cortexcode/`; the old TypeScript build
+ * read `.hoocode/`. Without the right one, the workspace silently falls back
+ * to the global mode and nothing asks.
+ *
+ * Only written when missing, so a real project's own config is never clobbered.
+ */
+export function prepareWorkspace() {
+  mkdirSync(config.workdir, { recursive: true });
+
+  const hooDir = join(config.workdir, ".cortexcode");
+  const cfgPath = join(hooDir, "hoo-config.json");
+  if (!existsSync(cfgPath)) {
+    mkdirSync(hooDir, { recursive: true });
+    writeFileSync(
+      cfgPath,
+      JSON.stringify(
+        {
+          active_mode: "discord",
+          modes: { discord: { auto_allow: ["read"] } },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    console.log(`Wrote ${cfgPath} (bash/edit/write will ask in Discord first)`);
+  }
+
+  const promptPath = join(hooDir, "modes", "discord", "system.md");
+  if (!existsSync(promptPath)) {
+    mkdirSync(join(hooDir, "modes", "discord"), { recursive: true });
+    writeFileSync(
+      promptPath,
+      [
+        "You are being used through a Discord chat.",
+        "",
+        "- Keep replies short. Discord messages are capped at 2000 characters.",
+        "- Use short lines, simple headings and bullet lists; avoid wide tables.",
+        "- Put code and command output in fenced code blocks.",
+        "- bash, edit and write need the user's approval via a button;",
+        "  if a call is denied, ask what they want instead of retrying.",
+        "- Never commit or push unless asked.",
+        "",
+      ].join("\n"),
+    );
+  }
+}

package/src/format.ts

@@ -0,0 +1,82 @@
+/** Discord hard limit is 2000; leave room for fence repair. */
+const LIMIT = 1900;
+
+/**
+ * Split text into Discord-sized chunks, preferring line breaks and keeping
+ * fenced code blocks valid across chunk boundaries.
+ */
+export function splitMessage(text: string, limit = LIMIT): string[] {
+  const chunks: string[] = [];
+  let current = "";
+  let openFence: string | null = null; // e.g. "```ts" while inside a block
+
+  const flush = () => {
+    if (!current.trim()) return;
+    chunks.push(openFence ? current + "\n```" : current);
+    current = openFence ? openFence + "\n" : "";
+  };
+
+  for (const rawLine of text.split("\n")) {
+    // Hard-wrap single lines longer than the limit.
+    const pieces: string[] = [];
+    for (let i = 0; i < rawLine.length || i === 0; i += limit - 20) {
+      pieces.push(rawLine.slice(i, i + limit - 20));
+      if (rawLine.length === 0) break;
+    }
+
+    for (const line of pieces) {
+      const addition = (current ? "\n" : "") + line;
+      if (current.length + addition.length > limit) flush();
+      current += (current && !current.endsWith("\n") ? "\n" : "") + line;
+
+      const fence = line.trim().match(/^```(\S*)/);
+      if (fence) openFence = openFence ? null : "```" + (fence[1] ?? "");
+    }
+  }
+  if (current.trim()) chunks.push(current);
+  return chunks.length ? chunks : [""];
+}
+
+export function truncate(text: string, max: number): string {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "…" : oneLine;
+}
+
+/** Inline code that survives backticks in the content. */
+export function code(text: string): string {
+  const clean = text.replace(/`/g, "ˋ");
+  return "`" + clean + "`";
+}
+
+/** Short human description of a tool call, e.g. "bash `ls -la`". */
+export function describeTool(name: string, args: Record<string, any> = {}): string {
+  const path = args.path ?? args.file_path;
+  switch (name) {
+    case "bash":
+      return `bash ${code(truncate(String(args.command ?? ""), 120))}`;
+    case "read":
+    case "edit":
+    case "write":
+      return `${name} ${code(truncate(String(path ?? "?"), 120))}`;
+    case "SearchCodebase":
+      return `search ${code(truncate(String(args.query ?? ""), 100))}`;
+    case "webfetch":
+      return `fetch ${code(truncate(String(args.url ?? ""), 120))}`;
+    case "websearch":
+      return `web search ${code(truncate(String(args.query ?? ""), 100))}`;
+    case "Task":
+      return `subagent ${code(truncate(String(args.description ?? args.subagent_type ?? ""), 80))}`;
+    default:
+      return code(name);
+  }
+}
+
+/** Plain text of an assistant message's text blocks. */
+export function assistantText(message: any): string {
+  if (!message || !Array.isArray(message.content)) return "";
+  return message.content
+    .filter((c: any) => c?.type === "text" && typeof c.text === "string")
+    .map((c: any) => c.text)
+    .join("\n\n")
+    .trim();
+}

package/src/index.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env bun
+/**
+ * hoo-discord-bot: talk to hoocode from Discord.
+ *
+ * - Mention the bot in a channel → it opens a thread and answers there.
+ * - Every message in that thread goes to the same hoocode session.
+ * - Commands inside a thread: !stop  !new  !status  !model <pattern>  !help
+ */
+import {
+  ChannelType,
+  Client,
+  Events,
+  GatewayIntentBits,
+  Partials,
+  type Message,
+  type ThreadChannel,
+} from "discord.js";
+import { config, prepareWorkspace } from "./config.ts";
+import { CodexClient } from "./codex-client.ts";
+import { LinkStore } from "./links.ts";
+import { ThreadSession } from "./session.ts";
+
+prepareWorkspace();
+
+const links = new LinkStore(config.linksFile);
+const sessions = new Map<string, ThreadSession>();
+
+/** `unix://PATH`, or `hoocode app-server` over stdio in the work folder. */
+function endpoint(): string {
+  if (config.appServer) return config.appServer;
+  return `stdio:${config.hoocodeBin} app-server ${config.hoocodeArgs.join(" ")}`;
+}
+
+let app: Promise<CodexClient> | null = null;
+
+/** The shared app-server connection; reconnects after it drops. */
+function appServer(): Promise<CodexClient> {
+  app ??= (async () => {
+    // A stdio server runs in the work folder; a socket server has its own.
+    const client = await CodexClient.connect(
+      endpoint(),
+      { name: "hoobot", version: "0.1.0" },
+      { cwd: config.workdir },
+    );
+    console.log(`Connected to app-server ${client.endpoint}`);
+    client.on("close", (reason: string) => {
+      console.error(`app-server connection closed: ${reason}`);
+      app = null;
+      // Sessions hold the old client; drop them. Threads resume on the next message.
+      for (const s of [...sessions.values()]) s.close();
+    });
+    return client;
+  })().catch((err) => {
+    console.error(`Can't reach app-server: ${err instanceof Error ? err.message : String(err)}`);
+    app = null;
+    throw err;
+  });
+  return app;
+}
+/** Threads this bot created, so it only listens in its own threads. */
+const ownThreads = new Set<string>();
+
+const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+  ],
+  partials: [Partials.Channel],
+});
+
+const HELP = [
+  "**hoo: hoocode in Discord**",
+  "",
+  "**Start:** mention me with a request. I'll open a thread.",
+  "**Continue:** just type in the thread.",
+  "",
+  "**Commands (inside a thread)**",
+  "- `!stop`: stop the current run",
+  "- `!new`: forget this conversation, start fresh",
+  "- `!status`: model, busy or not, folder",
+  "- `!model <name>`: switch model from the next message, e.g. `!model anthropic/claude-sonnet-4-5`",
+  "- `!help`: this message",
+  "",
+  "Typing while I'm busy steers the current run.",
+  "Commands that change files or run shell ask for approval with buttons.",
+].join("\n");
+
+client.once(Events.ClientReady, (c) => {
+  console.log(`Logged in as ${c.user.tag}`);
+  console.log(`Working folder: ${config.workdir}`);
+  console.log(`Allowed users: ${[...config.allowedUserIds].join(", ")}`);
+});
+
+client.on(Events.MessageCreate, async (message) => {
+  try {
+    await onMessage(message);
+  } catch (err) {
+    console.error("message handler failed", err);
+    await message.reply("Something went wrong on my side. Check the bot's terminal.").catch(() => {});
+  }
+});
+
+async function onMessage(message: Message) {
+  if (message.author.bot || !client.user) return;
+  if (config.guildId && message.guildId !== config.guildId) return;
+
+  const channel = message.channel;
+  const inOwnThread = channel.isThread() && isOwnThread(channel);
+  // Discord's autocomplete often picks the bot's auto-created *role* (also
+  // named after the bot) instead of the bot user, so accept either.
+  const botRoleId = message.guild?.members.me?.roles.botRole?.id;
+  const mentioned =
+    message.mentions.users.has(client.user.id) ||
+    (!!botRoleId && message.mentions.roles.has(botRoleId));
+
+  if (!inOwnThread && !mentioned) return;
+  console.log(`[msg] ${message.author.username} (${message.author.id}) in ${channel.id}: ${message.content.slice(0, 80)}`);
+
+  const parentId = channel.isThread() ? channel.parentId : channel.id;
+  if (config.channelIds.size && (!parentId || !config.channelIds.has(parentId))) return;
+
+  if (!config.allowedUserIds.has(message.author.id)) {
+    if (mentioned) await message.reply("Sorry, you're not on this bot's allow list.");
+    return;
+  }
+
+  const text = message.content
+    .replace(new RegExp(`<@!?${client.user.id}>`, "g"), "")
+    .replace(botRoleId ? new RegExp(`<@&${botRoleId}>`, "g") : /$^/, "")
+    .trim();
+  const images = await imageAttachments(message);
+
+  if (!text && images.length === 0) {
+    await message.reply(HELP);
+    return;
+  }
+
+  // Resolve (or create) the thread for this conversation.
+  let thread: ThreadChannel;
+  if (channel.isThread()) {
+    thread = channel;
+    ownThreads.add(thread.id);
+  } else if (channel.type === ChannelType.GuildText) {
+    thread = await message.startThread({
+      name: (text || "hoocode").replace(/\s+/g, " ").slice(0, 90),
+      autoArchiveDuration: 1440,
+    });
+    ownThreads.add(thread.id);
+  } else {
+    await message.reply("Mention me in a normal text channel and I'll open a thread.");
+    return;
+  }
+
+  // Commands.
+  const [cmd, ...rest] = text.split(/\s+/);
+  const arg = rest.join(" ").trim();
+  if (cmd?.toLowerCase() === "!help") {
+    await thread.send(HELP);
+    return;
+  }
+  let session: ThreadSession;
+  try {
+    session = await getSession(thread);
+  } catch (err) {
+    await thread.send(`**Can't reach hoocode:** ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
+  switch (cmd?.toLowerCase()) {
+    case "!stop":
+      await session.abort();
+      return;
+    case "!new":
+      await session.newSession();
+      return;
+    case "!status":
+      await session.status();
+      return;
+    case "!model":
+      if (!arg) await thread.send("Usage: `!model provider/model-id`");
+      else await session.setModel(arg);
+      return;
+  }
+
+  await session.prompt(text || "(see attached image)", images);
+}
+
+async function getSession(thread: ThreadChannel): Promise<ThreadSession> {
+  const client = await appServer();
+  let s = sessions.get(thread.id);
+  if (!s) {
+    s = new ThreadSession(thread, client, links, (id) => sessions.delete(id));
+    sessions.set(thread.id, s);
+  }
+  return s;
+}
+
+/** A thread counts as ours if we created it or already hold a session for it. */
+function isOwnThread(thread: ThreadChannel): boolean {
+  return ownThreads.has(thread.id) || sessions.has(thread.id) || thread.ownerId === client.user?.id;
+}
+
+async function imageAttachments(message: Message) {
+  const out: { data: string; mimeType: string }[] = [];
+  for (const att of message.attachments.values()) {
+    const mime = att.contentType?.split(";")[0] ?? "";
+    if (!mime.startsWith("image/") || att.size > 5_000_000) continue;
+    const res = await fetch(att.url);
+    if (!res.ok) continue;
+    out.push({ data: Buffer.from(await res.arrayBuffer()).toString("base64"), mimeType: mime });
+  }
+  return out;
+}
+
+function shutdown() {
+  console.log("Shutting down…");
+  for (const s of [...sessions.values()]) s.close();
+  app?.then((c) => c.close()).catch(() => {});
+  client.destroy().finally(() => process.exit(0));
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+client.login(config.token);

package/src/links.ts

@@ -0,0 +1,43 @@
+/**
+ * Surface thread → app-server thread links (design doc 13). hoocode never
+ * learns about Discord; this small JSON file is the only place that does.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export type Link = { threadId: string };
+
+export class LinkStore {
+  private links: Record<string, Link> = {};
+
+  constructor(private readonly path: string) {
+    if (existsSync(path)) {
+      try {
+        this.links = JSON.parse(readFileSync(path, "utf8"));
+      } catch (err) {
+        console.error(`Could not read ${path}; starting with no links`, err);
+      }
+    }
+  }
+
+  get(key: string): Link | undefined {
+    return this.links[key];
+  }
+
+  set(key: string, link: Link) {
+    this.links[key] = link;
+    this.save();
+  }
+
+  delete(key: string) {
+    delete this.links[key];
+    this.save();
+  }
+
+  private save() {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const tmp = `${this.path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(this.links, null, 2) + "\n");
+    renameSync(tmp, this.path);
+  }
+}

package/src/session.ts

@@ -0,0 +1,423 @@
+/**
+ * One Discord thread ⇄ one app-server thread. Translates Codex app-server
+ * notifications into Discord messages and approval requests into buttons.
+ * Uses only standard Codex methods, so it works against `hoocode app-server`
+ * and the real `codex app-server` alike.
+ */
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ComponentType,
+  type Message,
+} from "discord.js";
+import { config } from "./config.ts";
+import { code, describeTool, splitMessage, truncate } from "./format.ts";
+import { CodexClient, RpcError, userInput, type Notification, type RequestId, type ServerRequest } from "./codex-client.ts";
+import type { LinkStore } from "./links.ts";
+
+/** The bits of a Discord thread this file uses (tests pass a fake). */
+export interface ThreadLike {
+  id: string;
+  send(content: any): Promise<any>;
+  sendTyping(): Promise<unknown>;
+}
+
+type ToolLine = { id: string; text: string; state: "running" | "ok" | "error" | "declined" };
+
+type Approval = { msg: Message | null; title: string; resolved: boolean };
+
+export class ThreadSession {
+  private threadId: string | null = null;
+  private turnId: string | null = null;
+  private tools: ToolLine[] = [];
+  private progressMsg: Message | null = null;
+  private progressDirty = false;
+  private progressTimer: ReturnType<typeof setInterval>;
+  private typingTimer: ReturnType<typeof setInterval> | null = null;
+  private idleTimer: ReturnType<typeof setTimeout> | null = null;
+  private approvals = new Map<RequestId, Approval>();
+  private model: string | null = null;
+  /** Serialises Discord sends so replies stay in order. */
+  private queue: Promise<unknown> = Promise.resolve();
+  private ready: Promise<void> | null = null;
+  private closed = false;
+
+  constructor(
+    readonly thread: ThreadLike,
+    private readonly client: CodexClient,
+    private readonly links: LinkStore,
+    private onClose: (threadId: string) => void,
+  ) {
+    client.on("notification", this.onNotification);
+    client.on("request", this.onRequest);
+    this.progressTimer = setInterval(() => this.flushProgress(), 1500);
+    this.touch();
+  }
+
+  private get linkKey() {
+    return `discord:${this.thread.id}`;
+  }
+
+  get busy() {
+    return this.turnId !== null;
+  }
+
+  /** Resume the linked thread, or start a new one. Idempotent. */
+  private ensureThread(): Promise<void> {
+    this.ready ??= (async () => {
+      const link = this.links.get(this.linkKey);
+      if (link) {
+        try {
+          const res = await this.client.request("thread/resume", { threadId: link.threadId });
+          this.adopt(res);
+          return;
+        } catch (err) {
+          console.error(`[${this.thread.id}] resume ${link.threadId} failed; starting fresh`, err);
+          await this.post(`Couldn't reopen the earlier conversation (${code(errorText(err))}). Starting a new one.`);
+        }
+      }
+      await this.startThread();
+    })().catch((err) => {
+      this.ready = null;
+      throw err;
+    });
+    return this.ready;
+  }
+
+  private async startThread() {
+    const params: Record<string, unknown> = {};
+    if (config.model) params.model = config.model;
+    const res = await this.client.request("thread/start", params);
+    this.adopt(res);
+    this.links.set(this.linkKey, { threadId: res.thread.id });
+  }
+
+  private adopt(res: any) {
+    this.threadId = res.thread.id;
+    this.model = res.model ?? null;
+    // A turn still running on the server (e.g. after a bot restart).
+    const running = (res.thread.turns ?? []).findLast?.((t: any) => t.status === "inProgress");
+    this.turnId = running?.id ?? null;
+    if (this.turnId) this.startTyping();
+  }
+
+  // ── Input from Discord ─────────────────────────────────────────────────────
+
+  async prompt(text: string, images: { data: string; mimeType: string }[] = []) {
+    this.touch();
+    await this.ensureThread();
+    const input = userInput(text, images);
+    // One turn at a time: while one runs, the message steers it.
+    if (this.turnId) {
+      try {
+        await this.client.request("turn/steer", { threadId: this.threadId, input, expectedTurnId: this.turnId });
+        await this.post("Queued. It'll be read after the current step.");
+        return;
+      } catch (err) {
+        // The turn ended in the meantime: start a new one below.
+        if (!(err instanceof RpcError)) throw err;
+      }
+    }
+    try {
+      const params: Record<string, unknown> = { threadId: this.threadId, input };
+      if (this.pendingModel) params.model = this.pendingModel;
+      const res = await this.client.request("turn/start", params);
+      if (this.pendingModel) {
+        this.model = this.pendingModel;
+        this.pendingModel = null;
+      }
+      this.beginTurn(res.turn.id);
+    } catch (err) {
+      await this.post(`**Not sent:** ${errorText(err)}`);
+    }
+  }
+
+  async abort() {
+    if (!this.turnId || !this.threadId) {
+      await this.post("Nothing is running.");
+      return;
+    }
+    try {
+      await this.client.request("turn/interrupt", { threadId: this.threadId, turnId: this.turnId });
+      await this.post("**Stopped.**");
+    } catch (err) {
+      await this.post(`**Could not stop:** ${errorText(err)}`);
+    }
+  }
+
+  async newSession() {
+    if (this.turnId && this.threadId) {
+      await this.client.request("turn/interrupt", { threadId: this.threadId, turnId: this.turnId }).catch(() => {});
+    }
+    if (this.threadId) await this.client.request("thread/unsubscribe", { threadId: this.threadId }).catch(() => {});
+    this.turnId = null;
+    this.ready = this.startThread();
+    try {
+      await this.ready;
+      await this.post("**New session.** Earlier messages are forgotten.");
+    } catch (err) {
+      this.ready = null;
+      await this.post(`**Failed:** ${errorText(err)}`);
+    }
+  }
+
+  async status() {
+    await this.ensureThread();
+    const lines = [
+      "**Status**",
+      `- Model: ${code(this.pendingModel ?? this.model ?? "default")}`,
+      `- Busy: ${this.turnId ? "yes" : "no"}`,
+      `- Thread: ${code(this.threadId ?? "none")}`,
+      `- Server: ${code(this.client.endpoint)}`,
+    ];
+    await this.post(lines.join("\n"));
+  }
+
+  private pendingModel: string | null = null;
+
+  /** Takes effect on the next turn (`turn/start` `model`). */
+  async setModel(name: string) {
+    this.pendingModel = name;
+    await this.post(`**Model:** ${code(name)} from the next message.`);
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.threadId) this.client.request("thread/unsubscribe", { threadId: this.threadId }).catch(() => {});
+    this.dispose();
+  }
+
+  // ── Output to Discord ──────────────────────────────────────────────────────
+
+  private beginTurn(turnId: string) {
+    if (this.turnId === turnId) return;
+    this.turnId = turnId;
+    this.tools = [];
+    this.progressMsg = null;
+    this.startTyping();
+  }
+
+  private onNotification = (n: Notification) => {
+    const p = n.params ?? {};
+    if (p.threadId !== undefined && p.threadId !== this.threadId) return;
+    if (n.method === "thread/started" && p.thread?.id !== this.threadId) return;
+    this.handleNotification(n).catch((err) => console.error(`[${this.thread.id}] event error`, err));
+  };
+
+  private async handleNotification({ method, params: p }: Notification) {
+    switch (method) {
+      case "turn/started":
+        this.beginTurn(p.turn.id);
+        break;
+
+      case "turn/completed": {
+        if (p.turn.id !== this.turnId) break;
+        this.turnId = null;
+        this.stopTyping();
+        await this.flushProgress();
+        if (p.turn.status === "failed" && p.turn.error?.message) {
+          await this.post(`**Error:**\n${"```"}\n${truncate(p.turn.error.message, 1500)}\n${"```"}`);
+        }
+        this.touch();
+        break;
+      }
+
+      case "item/started": {
+        const tool = toolLine(p.item);
+        if (tool) {
+          this.tools.push(tool);
+          this.progressDirty = true;
+        }
+        break;
+      }
+
+      case "item/completed": {
+        const item = p.item;
+        if (item.type === "agentMessage" && item.text?.trim()) {
+          // Text closes the current tool list; the next tools start a fresh one.
+          await this.flushProgress();
+          this.progressMsg = null;
+          this.tools = [];
+          for (const chunk of splitMessage(item.text)) await this.post(chunk);
+          break;
+        }
+        const t = this.tools.find((x) => x.id === item.id);
+        if (t) {
+          t.state = item.status === "declined" ? "declined" : item.status === "failed" ? "error" : "ok";
+          this.progressDirty = true;
+        }
+        break;
+      }
+
+      case "serverRequest/resolved":
+        await this.resolveApproval(p.requestId, null);
+        break;
+    }
+  }
+
+  /** Tool activity as one message, edited in place (throttled). */
+  private async flushProgress() {
+    if (!this.progressDirty || this.tools.length === 0) return;
+    this.progressDirty = false;
+    // Words, not just symbols, so state doesn't rely on colour or icon shape.
+    const label = { running: "⏳ running", ok: "✅ done", error: "❌ failed", declined: "🚫 denied" } as const;
+    const lines = this.tools.slice(-15).map((t) => `${label[t.state]} · ${t.text}`);
+    const hidden = this.tools.length - 15;
+    if (hidden > 0) lines.unshift(`*…${hidden} earlier steps*`);
+    const body = lines.join("\n").slice(-1900);
+    await this.enqueue(async () => {
+      if (this.progressMsg) await this.progressMsg.edit(body).catch(() => {});
+      else this.progressMsg = await this.thread.send(body);
+    });
+  }
+
+  // ── Approvals ──────────────────────────────────────────────────────────────
+
+  private onRequest = (r: ServerRequest) => {
+    if (r.params?.threadId !== this.threadId) return;
+    this.handleRequest(r).catch((err) => console.error(`[${this.thread.id}] request error`, err));
+  };
+
+  private async handleRequest(r: ServerRequest) {
+    if (r.method !== "item/commandExecution/requestApproval" && r.method !== "item/fileChange/requestApproval") {
+      // Not something Discord can answer; say no rather than leave it hanging.
+      this.client.respond(r.id, { decision: "decline" });
+      return;
+    }
+    if (this.approvals.has(r.id)) return;
+    const p = r.params;
+    const what =
+      r.method === "item/commandExecution/requestApproval"
+        ? p.command
+          ? `bash ${code(truncate(p.command, 300))}`
+          : (p.reason ?? "run a command")
+        : (p.reason?.replace(/^Allow:\s*/, "") ?? "change files");
+    const title = `**Approval needed**\n${what}`;
+    const approval: Approval = { msg: null, title, resolved: false };
+    this.approvals.set(r.id, approval);
+
+    // No "always" button: it would change hoocode's global config.
+    const options = [
+      { label: "Allow once", decision: "accept", style: ButtonStyle.Success },
+      { label: "Deny", decision: "decline", style: ButtonStyle.Danger },
+    ];
+    const row = new ActionRowBuilder<ButtonBuilder>().addComponents(
+      options.map((o, i) => new ButtonBuilder().setCustomId(`ui:${i}`).setLabel(o.label).setStyle(o.style)),
+    );
+    const msg = (await this.enqueue(() => this.thread.send({ content: title.slice(0, 1800), components: [row] }))) as Message;
+    approval.msg = msg;
+    this.stopTyping();
+    if (approval.resolved) {
+      // Answered elsewhere while we were sending.
+      await this.markResolved(approval, "**Answered elsewhere.**");
+      return;
+    }
+    try {
+      const click = await msg.awaitMessageComponent({
+        componentType: ComponentType.Button,
+        time: config.approvalTimeoutMs,
+        filter: async (i) => {
+          if (config.allowedUserIds.has(i.user.id)) return true;
+          await i.reply({ content: "Only allowed users can answer this.", ephemeral: true }).catch(() => {});
+          return false;
+        },
+      });
+      if (approval.resolved) {
+        await click.update({ content: `${title.slice(0, 1800)}\n→ **Answered elsewhere.**`, components: [] }).catch(() => {});
+        return;
+      }
+      const chosen = options[Number(click.customId.split(":")[1])]!;
+      approval.resolved = true;
+      this.client.respond(r.id, { decision: chosen.decision });
+      await click.update({ content: `${title.slice(0, 1800)}\n→ **${chosen.label}** by ${click.user.username}`, components: [] });
+    } catch {
+      if (approval.resolved) return;
+      approval.resolved = true;
+      this.client.respond(r.id, { decision: "decline" });
+      await this.markResolved(approval, "**No answer, denied.**");
+    }
+    if (this.turnId) this.startTyping();
+  }
+
+  /** The server says request `id` is settled (answered by any client, or the turn ended). */
+  private async resolveApproval(id: RequestId, _: null) {
+    const approval = this.approvals.get(id);
+    if (!approval) return;
+    this.approvals.delete(id);
+    if (approval.resolved) return;
+    approval.resolved = true;
+    if (approval.msg) await this.markResolved(approval, "**Answered elsewhere.**");
+  }
+
+  private async markResolved(approval: Approval, note: string) {
+    await approval.msg?.edit({ content: `${approval.title.slice(0, 1800)}\n→ ${note}`, components: [] }).catch(() => {});
+  }
+
+  // ── Helpers ────────────────────────────────────────────────────────────────
+
+  private post(text: string) {
+    if (!text.trim()) return Promise.resolve();
+    return this.enqueue(() => this.thread.send(text)).catch((err) => console.error(`[${this.thread.id}] send failed`, err));
+  }
+
+  private enqueue<T>(fn: () => Promise<T>): Promise<T> {
+    const next = this.queue.then(fn, fn);
+    this.queue = next.catch(() => {});
+    return next;
+  }
+
+  private startTyping() {
+    if (this.typingTimer) return;
+    this.thread.sendTyping().catch(() => {});
+    this.typingTimer = setInterval(() => this.thread.sendTyping().catch(() => {}), 8000);
+  }
+
+  private stopTyping() {
+    if (this.typingTimer) clearInterval(this.typingTimer);
+    this.typingTimer = null;
+  }
+
+  /** Let go of idle threads; the server keeps them on disk. */
+  private touch() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      if (!this.turnId && this.approvals.size === 0) this.close();
+      else this.touch();
+    }, config.idleTimeoutMs);
+  }
+
+  private dispose() {
+    clearInterval(this.progressTimer);
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.stopTyping();
+    this.client.off("notification", this.onNotification);
+    this.client.off("request", this.onRequest);
+    this.onClose(this.thread.id);
+  }
+}
+
+/** A progress line for a tool-ish item, or null for messages. */
+function toolLine(item: any): ToolLine | null {
+  switch (item?.type) {
+    case "commandExecution":
+      return { id: item.id, text: describeTool("bash", { command: item.command }), state: "running" };
+    case "fileChange": {
+      const paths = (item.changes ?? []).map((c: any) => c.path).join(", ");
+      return { id: item.id, text: `edit ${code(truncate(paths || "?", 120))}`, state: "running" };
+    }
+    case "dynamicToolCall":
+      return { id: item.id, text: describeTool(item.tool, item.arguments ?? {}), state: "running" };
+    case "mcpToolCall":
+      return { id: item.id, text: code(`${item.server}/${item.tool}`), state: "running" };
+    case "webSearch":
+      return { id: item.id, text: `web search ${code(truncate(String(item.query ?? ""), 100))}`, state: "running" };
+    default:
+      return null;
+  }
+}
+
+function errorText(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}