@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/host/daemon/api/tasks.js

@@ -3,12 +3,22 @@
 //   GET    /projects/:pid/tasks                  ?state=open|done|dropped|all&tag=X&agent=Y
 //                                                &due_before=ISO&due_after=ISO&limit=N
 //                                                &status=pending|running|in_review|blocked&updated_since=ISO
-//   POST   /projects/:pid/tasks                  { title, body?, tags?, due?, agent?, source?, meta? }
+//   POST   /projects/:pid/tasks                  { title, description?, body?, tags?, due?,
+//                                                agent?, source?, meta? }
 //   GET    /projects/:pid/tasks/:id              (id or prefix)
 //   PATCH  /projects/:pid/tasks/:id              { patch: {...} }
 //   POST   /projects/:pid/tasks/:id/done         { by? }
 //   POST   /projects/:pid/tasks/:id/drop         { by? }
 //   POST   /projects/:pid/tasks/:id/reopen
+//   POST   /projects/:pid/tasks/:id/comments    { text, by? } — @mentions summon agents
+//   GET    /tasks/columns                       the GLOBAL board-column catalog
+//   PUT    /tasks/columns                       { columns: [{id,label?}] }
+//   GET    /projects/:pid/tasks/columns         { columns, catalog } for that project
+//   PUT    /projects/:pid/tasks/columns         { columns: [id] } — a subset of the catalog
+//
+// `?parent=<id>` on either list route returns that task's SUBTASKS; `?parent=`
+// (empty) returns only top-level tasks. A subtask is a task with a parent, so
+// every verb above works on one unchanged.
 import {
   createTask,
   listTasks,
@@ -20,16 +30,47 @@ import {
   reopenTask,
   setTaskStatus,
   countTasks,
-  TASK_STATUSES,
 } from "#core/stores/tasks.js";
+import { addComment } from "#core/stores/tasks.js";
+import { readConfig, writeConfig } from "#core/config/index.js";
+import {
+  DONE_COLUMN, columnHook, normalizeColumns, isColumnId, projectColumns, readColumnCatalog,
+} from "#core/tasks/columns.js";
+import { readAgents } from "#core/apc/parser.js";
+import { readProjectConfig, writeProjectConfig } from "../project-config.js";
+import { mentionedAgents, runCommentMentions } from "#core/tasks/comment-turn.js";
+import { OWNER_ACTOR_ID } from "#core/constants/actors.js";
 import { pageEnvelope } from "./shared.js";
 
-export function register(api, { project, projects }) {
+/** What the board says when a column has an agent but no instruction. */
+function defaultHookLine(label) {
+  return `esta task pasó a "${label}". Hacé lo que corresponda y dejá el resultado acá.`;
+}
+
+/**
+ * Is this column's agent already working on this task?
+ *
+ * The newest comment being an owner-authored summon of that same agent means we
+ * asked and nothing has come back yet — the moment the agent replies, ITS
+ * comment is the newest one and a genuine re-run is allowed again. Without this,
+ * dragging a card out of a column and back in (a thing people do constantly)
+ * starts a second paid run on top of the first.
+ *
+ * Matching on `mentions` rather than on the text: the summon line is the
+ * column's own instruction when it has one, so there is no wording to look for.
+ */
+function hookAlreadyRunning(task, agent) {
+  const last = task.comments?.[task.comments.length - 1];
+  if (!last) return false;
+  return last.by === OWNER_ACTOR_ID && (last.mentions || []).includes(agent);
+}
+
+export function register(api, { project, projects, config, plugins, registries }) {
   // Global tasks across every project, newest first. Returns a { meta, data }
   // envelope. Paginated via ?limit & ?offset; with no limit, data is the full
   // set as one page.
   api.get("/tasks", (req, res) => {
-    const { state, tag, agent, due_before, due_after, status, updated_since } = req.query;
+    const { state, tag, agent, due_before, due_after, status, updated_since, parent } = req.query;
 
     // Resolve the registered projects to what core needs, dropping any the
     // manager can no longer open.
@@ -46,13 +87,17 @@ export function register(api, { project, projects }) {
     }
 
     const { tasks, skipped } = listTasksAcrossProjects(entries, {
-      state: state === "all" ? undefined : (state || "open"),
+      // "all" is passed THROUGH, not turned into undefined: listTasks reads a
+      // missing state as "open only", so mapping all→undefined made the
+      // aggregated view's All chip show exactly the same rows as Open.
+      state: state || "open",
       tag: tag || undefined,
       agent: agent || undefined,
       due_before: due_before || undefined,
       due_after: due_after || undefined,
       status: status || undefined,
       updated_since: updated_since || undefined,
+      ...(parent !== undefined ? { parent } : {}),
     });
 
     const envelope = pageEnvelope(tasks, req.query);
@@ -61,12 +106,67 @@ export function register(api, { project, projects }) {
     res.json(envelope);
   });
 
+  // The vocabulary every board shares. Editing it here renames/adds/removes a
+  // column for every project at once, which is the point: "QA" has to mean the
+  // same thing everywhere or an agent told to move something to QA has to ask
+  // which one. What each project SHOWS is the per-project route below.
+  api.get("/tasks/columns", (_req, res) => {
+    res.json({ columns: readColumnCatalog(readConfig()) });
+  });
+
+  api.put("/tasks/columns", (req, res) => {
+    const { columns } = req.body || {};
+    if (!Array.isArray(columns) || columns.length === 0) {
+      return res.status(400).json({ error: "columns must be a non-empty array" });
+    }
+    const bad = columns.find((c) => !isColumnId(typeof c === "string" ? c : c?.id));
+    if (bad) {
+      return res.status(400).json({
+        error: `invalid column id: ${JSON.stringify(typeof bad === "string" ? bad : bad?.id)} ` +
+          `(lowercase letters, digits, - and _; "${DONE_COLUMN}" is reserved)`,
+      });
+    }
+    const cfg = readConfig();
+    const next = normalizeColumns(columns);
+    writeConfig({ ...cfg, tasks: { ...(cfg.tasks || {}), columns: next } });
+    res.json({ columns: next });
+  });
+
+  // What THIS project shows, in order, with `done` appended — plus the catalog
+  // it may pick from, so the editor needs one request instead of two.
+  api.get("/projects/:pid/tasks/columns", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const global = readConfig();
+    res.json({
+      columns: projectColumns(global, readProjectConfig(p.path)),
+      catalog: readColumnCatalog(global),
+    });
+  });
+
+  api.put("/projects/:pid/tasks/columns", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { columns } = req.body || {};
+    if (!Array.isArray(columns)) return res.status(400).json({ error: "columns must be an array" });
+    const global = readConfig();
+    const known = new Set(readColumnCatalog(global).map((c) => c.id));
+    const picked = [...new Set(columns.map((c) => String(c?.id || c || "").trim().toLowerCase()))]
+      .filter((id) => known.has(id));
+    const cfg = readProjectConfig(p.path);
+    writeProjectConfig(p.path, { ...cfg, tasks: { ...(cfg.tasks || {}), columns: picked } });
+    res.json({
+      columns: projectColumns(global, readProjectConfig(p.path)),
+      catalog: readColumnCatalog(global),
+    });
+  });
+
   // Per-project tasks. Returns a { meta, data } envelope; with no ?limit the
   // data array is the full filtered set (one page).
   api.get("/projects/:pid/tasks", (req, res) => {
     const p = project(req, res);
     if (!p) return;
-    const { state, tag, agent, due_before, due_after, status, updated_since } = req.query;
+    const { state, tag, agent, due_before, due_after, status, updated_since, parent } = req.query;
     const all = listTasks(p.storagePath, {
       state: state || undefined,
       tag: tag || undefined,
@@ -75,6 +175,7 @@ export function register(api, { project, projects }) {
       due_after: due_after || undefined,
       status: status || undefined,
       updated_since: updated_since || undefined,
+      ...(parent !== undefined ? { parent } : {}),
     });
     res.json(pageEnvelope(all, req.query));
   });
@@ -136,18 +237,87 @@ export function register(api, { project, projects }) {
     res.json(updated);
   });
 
-  // Move an open task through its workflow (pending → running → in_review …).
+  // Move an open task to a column. The valid set is the project's own columns
+  // (core/tasks/columns.js) — not the four built-ins, which are only the default
+  // catalog. `done` is not among them: closing a task is POST …/done, and a
+  // board that let you *set* done would leave state and status disagreeing.
   api.post("/projects/:pid/tasks/:id/status", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const { status } = req.body || {};
-    if (!TASK_STATUSES.includes(status))
-      return res.status(400).json({ error: `status must be one of ${TASK_STATUSES.join(", ")}` });
-    const updated = setTaskStatus(p.storagePath, req.params.id, status);
+    const columns = projectColumns(readConfig(), readProjectConfig(p.path));
+    const statuses = columns.map((c) => c.id).filter((id) => id !== DONE_COLUMN);
+    if (!statuses.includes(status)) {
+      return res.status(400).json({ error: `status must be one of ${statuses.join(", ")}` });
+    }
+    const updated = setTaskStatus(p.storagePath, req.params.id, status, { statuses });
     if (!updated) return res.status(404).json({ error: "task not found" });
+
+    // Column automation: dropping a card in a column that has one hands the task
+    // to an agent. It runs through the SAME path a human @mention takes — the
+    // handover is written into the thread first, so the board never does
+    // anything invisible, and the reply comes back as a comment under the same
+    // ceiling. Fire-and-forget: a real QA run takes as long as the QA takes.
+    const hook = columnHook(columns, status);
+    if (hook && !hookAlreadyRunning(updated, hook.agent)) {
+      let hasAgent = false;
+      try { hasAgent = readAgents(p.path).some((a) => a.slug === hook.agent); } catch { hasAgent = false; }
+      if (hasAgent) {
+        const label = columns.find((c) => c.id === status)?.label || status;
+        const text = hook.instruction
+          ? `@${hook.agent} ${hook.instruction}`
+          : `@${hook.agent} ${defaultHookLine(label)}`;
+        try {
+          addComment(p.storagePath, updated.id, {
+            by: OWNER_ACTOR_ID, text, mentions: [hook.agent],
+          });
+          runCommentMentions({
+            p, taskId: updated.id, seed: [hook.agent], author: OWNER_ACTOR_ID,
+            projects, plugins, registries, config,
+          }).catch(() => { /* the failure is written into the thread */ });
+        } catch { /* a broken hook must not fail the move */ }
+      }
+    }
+
     res.json(updated);
   });
 
+  // Add a comment. @-mentioning an agent hands it the task: it runs a REAL turn
+  // with its own tools and writes back another comment (core/tasks/comment-turn).
+  //
+  // The cascade is NOT awaited. An agent doing actual QA takes as long as the QA
+  // takes, and a request that hangs for it would time out on the phone and be
+  // retried into a second run. The comment is persisted before we answer, so the
+  // 201 is honest about what exists; the replies arrive in the thread after.
+  api.post("/projects/:pid/tasks/:id/comments", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { text, by = OWNER_ACTOR_ID } = req.body || {};
+    if (typeof text !== "string" || !text.trim()) {
+      return res.status(400).json({ error: "text required" });
+    }
+
+    // Resolved here, not in the store: the roster lives with the project and
+    // the thread should record who was actually reachable on the day.
+    const mentions = mentionedAgents(text, p.path, by);
+    let task;
+    try {
+      task = addComment(p.storagePath, req.params.id, { by, text, mentions });
+    } catch (e) {
+      return res.status(400).json({ error: e.message });
+    }
+    if (!task) return res.status(404).json({ error: "task not found" });
+
+    if (mentions.length) {
+      runCommentMentions({
+        p, taskId: task.id, seed: mentions, author: by,
+        projects, plugins, registries, config,
+      }).catch(() => { /* the failure is already written into the thread */ });
+    }
+
+    res.status(201).json({ task, summoned: mentions });
+  });
+
   // Lightweight summary endpoint for status displays.
   api.get("/projects/:pid/tasks-summary", (req, res) => {
     const p = project(req, res);

package/src/host/daemon/api/telegram.js

@@ -44,6 +44,7 @@ import {
 
 import { redactChannel, isSecretMarker } from "#core/config/redact.js";
 import { canNudge, recordNudge, nudgeFeedbackKeyboard } from "#core/nudge/index.js";
+import { asyncRoute } from "./shared.js";
 
 export function register(api, { telegram }) {
   api.get("/telegram/status", (_req, res) => {
@@ -73,7 +74,7 @@ export function register(api, { telegram }) {
     }
   });
 
-  api.post("/telegram/send", async (req, res) => {
+  api.post("/telegram/send", asyncRoute(async (req, res) => {
     const { chat_id, text, channel } = req.body || {};
     if (!text) return res.status(400).json({ error: "text required" });
     if (!telegram)
@@ -84,9 +85,9 @@ export function register(api, { telegram }) {
     } catch (e) {
       res.status(502).json({ error: e.message });
     }
-  });
+  }));
 
-  api.post("/telegram/send_photo", async (req, res) => {
+  api.post("/telegram/send_photo", asyncRoute(async (req, res) => {
     const { chat_id, photo, caption, parse_mode, channel } = req.body || {};
     if (!photo)
       return res.status(400).json({ error: "photo required (path or url)" });
@@ -104,9 +105,9 @@ export function register(api, { telegram }) {
     } catch (e) {
       res.status(502).json({ error: e.message });
     }
-  });
+  }));
 
-  api.post("/telegram/send_voice", async (req, res) => {
+  api.post("/telegram/send_voice", asyncRoute(async (req, res) => {
     const { chat_id, audio, caption, duration, channel } = req.body || {};
     if (!audio) return res.status(400).json({ error: "audio required (path)" });
     if (!telegram)
@@ -123,9 +124,9 @@ export function register(api, { telegram }) {
     } catch (e) {
       res.status(502).json({ error: e.message });
     }
-  });
+  }));
 
-  api.post("/telegram/send_audio", async (req, res) => {
+  api.post("/telegram/send_audio", asyncRoute(async (req, res) => {
     const { chat_id, audio, caption, title, performer, channel } =
       req.body || {};
     if (!audio) return res.status(400).json({ error: "audio required (path)" });
@@ -144,7 +145,7 @@ export function register(api, { telegram }) {
     } catch (e) {
       res.status(502).json({ error: e.message });
     }
-  });
+  }));
 
   // ── Channel CRUD (config-only; caller must POST /admin/reload to apply) ──
   // We read fresh config from disk on each call so concurrent writes from the
@@ -309,7 +310,7 @@ export function register(api, { telegram }) {
   // interruption budget applies by default. A caller delivering something the
   // user is waiting for says so with `unsolicited: false`, and that choice is
   // then visible in its own diff rather than hidden in this handler.
-  api.post("/telegram/notify", async (req, res) => {
+  api.post("/telegram/notify", asyncRoute(async (req, res) => {
     const { chat_id, text, channel, kind, project_id, severity, unsolicited } = req.body || {};
     if (!text) return res.status(400).json({ error: "text required" });
     if (!telegram)
@@ -348,5 +349,5 @@ export function register(api, { telegram }) {
     } catch (e) {
       res.status(502).json({ error: e.message });
     }
-  });
+  }));
 }

package/src/host/daemon/api/thread-faces.js

@@ -0,0 +1,159 @@
+// Who is in a multi-agent thread, and what that thread is CALLED.
+//
+// An a2a or group thread is a conversation BETWEEN agents, so every surface
+// that shows one — the inbox rows, the Chats sidebar, the thread header on the
+// desktop and on the phone — has to answer the same two questions: which faces
+// to draw, and what name to put on it. There was no single answer: the inbox
+// resolved both here in the API, the sidebar re-derived faces in React from its
+// own agent list, and the thread header could only do it when the inbox handed
+// it the row it had already resolved. Same ledger, three resolutions, two of
+// them incomplete — which is why `/inbox` drew "Andy · OpenCode" with both
+// avatars while `/p/0/chat` drew the same thread as a faceless `andy~opencode`.
+//
+// So it is answered ONCE, here, and travels ON the payload: `participant_faces`
+// plus a resolved `title`. Every frontend renders what it is given; none of them
+// re-derives a face from a slug.
+//
+// It lives at the surface rather than in core because the super-agent's display
+// name comes from identity.json and core must not reach for it (rule 4).
+import { readAgents } from "#core/apc/parser.js";
+import { resolveSuperAgentBlob } from "#core/apc/agent-identity.js";
+import { readConfig } from "#core/config/index.js";
+import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
+
+const LEGACY_SUPER_AGENT_SLUGS = new Set([
+  "default", "superagent", "super-agent", "super_agent", "apx", "roby", "__super_agent__",
+]);
+
+// Coding CLIs aren't project agents (no .apc file, so no face resolves), but an
+// a2a pair with one should read as its brand, not a bare lowercase slug. Keys
+// match the frontend's CLI_LOGOS so the logo still lands (it matches on the
+// lowercased name), the label just wears proper case.
+const CLI_DISPLAY_NAMES = {
+  claude: "Claude",
+  "claude-code": "Claude",
+  codex: "Codex",
+  opencode: "OpenCode",
+  cursor: "Cursor",
+  "cursor-agent": "Cursor",
+  aider: "Aider",
+  gemini: "Gemini",
+  qwen: "Qwen",
+};
+
+/** The three display fields an agent carries, from either shape it arrives in. */
+function faceOfAgent(a) {
+  return {
+    name: a?.fields?.Name || a?.name || null,
+    emoji: a?.fields?.Emoji || a?.emoji || null,
+    icon: a?.fields?.Icon || a?.icon || null,
+  };
+}
+
+/** An unreadable AGENTS.md is one project without faces, never a failed request. */
+export function readAgentsSafe(dir) {
+  try { return dir ? readAgents(dir) : []; } catch { return []; }
+}
+
+/**
+ * A resolver for one request: `slug → face`, and `thread → decorated thread`.
+ *
+ * `projectPaths` are the working-copy paths of every registered project, because
+ * an a2a pair can SPAN them — a coding CLI in one project talking to an agent
+ * that lives in another. A face looked up only in the thread's own project
+ * renders the outsider as a bare letter, so the cross-project index is the
+ * fallback. It is built lazily: a request whose participants all live in the
+ * caller's own roster never opens another project's AGENTS.md.
+ */
+export function createFaceResolver(projectPaths = []) {
+  let index = null;
+  const globalIndex = () => {
+    if (index) return index;
+    index = new Map();
+    for (const dir of projectPaths) {
+      // First project to define a slug wins — collisions are rare, and the
+      // caller's own roster is tried before this map anyway.
+      for (const a of readAgentsSafe(dir)) if (!index.has(a.slug)) index.set(a.slug, faceOfAgent(a));
+    }
+    return index;
+  };
+
+  let superFace = null;
+  const superAgentFace = () => {
+    if (superFace) return superFace;
+    let cfg = null;
+    try { cfg = readConfig(); } catch { /* no config is not a reason to draw nothing */ }
+    // The super-agent is not a project agent, so nothing above resolves it: it
+    // needs its persona name and its blob, or an a2a thread it is in renders the
+    // bare `super_agent` slug with no avatar.
+    superFace = {
+      slug: SUPERAGENT_ACTOR_ID,
+      name: resolveAgentName(cfg || {}),
+      emoji: null,
+      icon: resolveSuperAgentBlob(cfg || {}),
+    };
+    return superFace;
+  };
+
+  /** `localAgents` (the thread's own project roster) wins over every other project. */
+  const face = (slug, localAgents = []) => {
+    if (slug === SUPERAGENT_ACTOR_ID) return { ...superAgentFace() };
+    const local = localAgents.find((a) => a.slug === slug);
+    const hit = local ? faceOfAgent(local) : globalIndex().get(slug) || null;
+    if (!hit && LEGACY_SUPER_AGENT_SLUGS.has(String(slug).toLowerCase())) {
+      return { ...superAgentFace() };
+    }
+    if (!hit && String(slug).toLowerCase() === "roby-orchestrator") {
+      return {
+        slug,
+        name: "Roby Orchestrator",
+        emoji: null,
+        icon: superAgentFace().icon,
+      };
+    }
+    return {
+      // Physical key, so a surface can OPEN this agent and not just paint it.
+      slug,
+      // A project agent's own name; else a coding CLI's brand name (Claude,
+      // Cursor, OpenCode…) so it doesn't read as a bare lowercase slug; else
+      // the slug itself.
+      name: hit?.name || CLI_DISPLAY_NAMES[String(slug).toLowerCase()] || slug,
+      emoji: hit?.emoji || null,
+      icon: hit?.icon || null,
+    };
+  };
+
+  /**
+   * Add `participant_faces` and a display `title` to an a2a / group thread.
+   *
+   * Anything without participants (a Telegram day, a web thread) is returned
+   * untouched — this decorates multi-agent threads, it does not reshape the
+   * ledger.
+   *
+   * A title the STORE derived from slugs (`andy~claude-code`'s pair join, or a
+   * group with no name of its own) is the same question asked before the faces
+   * were known, so it is answered again with them: "Andy · Claude". A group
+   * someone actually named keeps that name.
+   */
+  const decorate = (thread, localAgents = []) => {
+    const participants = Array.isArray(thread?.participants) ? thread.participants : null;
+    if (!participants?.length) return thread;
+    const faces = participants.map((slug) => face(slug, localAgents));
+    const own = String(thread.title || "");
+    const isDerived = !own || own === participants.join(" · ") || own === thread.id;
+    return {
+      ...thread,
+      participant_faces: faces,
+      title: isDerived ? faces.map((f) => f.name).join(" · ") : own,
+    };
+  };
+
+  return { face, decorate };
+}
+
+/** The same resolver, built from a ProjectManager-style list of entries. */
+export function faceResolverFor(projects) {
+  let paths = [];
+  try { paths = projects.list().map((e) => e.path).filter(Boolean); } catch { /* none registered */ }
+  return createFaceResolver(paths);
+}

package/src/host/daemon/api/top-level.js

@@ -10,7 +10,7 @@
 //   POST /mcp/run                call an MCP tool
 import fs from "node:fs";
 import path from "node:path";
-import { resolveMemoryPath } from "./shared.js";
+import { resolveMemoryPath, asyncRoute } from "./shared.js";
 
 export function register(api, { projects, registries, resolveTopProject }) {
   // ---- /memory ----
@@ -117,7 +117,7 @@ export function register(api, { projects, registries, resolveTopProject }) {
     res.json(registries.for(p).list());
   });
 
-  api.post("/mcp/run", async (req, res) => {
+  api.post("/mcp/run", asyncRoute(async (req, res) => {
     const { project: projectRef, name, tool, params } = req.body || {};
     if (!name) return res.status(400).json({ error: "name required" });
     if (!tool) return res.status(400).json({ error: "tool required" });
@@ -129,5 +129,5 @@ export function register(api, { projects, registries, resolveTopProject }) {
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 }

package/src/host/daemon/api/transcribe.js

@@ -1,3 +1,4 @@
+import { asyncRoute } from "./shared.js";
 // POST /transcribe/chunk
 // Raw audio bytes in the body. Headers:
 //   X-Audio-Format  webm | ogg | wav | mp3 (defaults to webm)
@@ -10,7 +11,7 @@ export function register(api) {
   // admin (mirror of /tts/providers). local = embedded faster-whisper;
   // openai = cloud Whisper; custom = any OpenAI-compatible server (mlx-audio
   // on Metal, a Radeon/NVIDIA box on the LAN, a remote endpoint).
-  api.get("/transcribe/providers", async (_req, res) => {
+  api.get("/transcribe/providers", asyncRoute(async (_req, res) => {
     try {
       const { readConfig } = await import("#core/config/index.js");
       const { listSttProviders } = await import("#core/voice/transcription.js");
@@ -18,12 +19,12 @@ export function register(api) {
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 
   // GET /transcribe/hardware — detected machine + the recommended local backend
   // (mlx on Apple Silicon, faster-whisper cuda on NVIDIA, else CPU). Drives the
   // "engine adapts itself" UX in the web admin.
-  api.get("/transcribe/hardware", async (_req, res) => {
+  api.get("/transcribe/hardware", asyncRoute(async (_req, res) => {
     try {
       const { detectHardware, recommendStt } = await import("#core/voice/stt-hardware.js");
       const hw = detectHardware();
@@ -31,11 +32,11 @@ export function register(api) {
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 
   // GET /transcribe/models?backend=faster|mlx — model catalog with on-disk
   // status (downloaded? size) for the model-manager UI.
-  api.get("/transcribe/models", async (req, res) => {
+  api.get("/transcribe/models", asyncRoute(async (req, res) => {
     try {
       const backend = String(req.query.backend || "faster");
       const { listSttModels } = await import("#core/voice/stt-models.js");
@@ -43,21 +44,21 @@ export function register(api) {
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 
   // GET /transcribe/warmup — load the local whisper model (if needed) and reset
   // its idle watchdog. Callers (e.g. the desktop window) ping this while open so
   // the first real utterance doesn't pay the cold-load cost.
-  api.get("/transcribe/warmup", async (_req, res) => {
+  api.get("/transcribe/warmup", asyncRoute(async (_req, res) => {
     try {
       const { warmupWhisper } = await import("../whisper-server.js");
       res.json(await warmupWhisper());
     } catch (e) {
       res.status(500).json({ ok: false, error: e.message });
     }
-  });
+  }));
 
-  api.post("/transcribe/chunk", async (req, res) => {
+  api.post("/transcribe/chunk", asyncRoute(async (req, res) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", async () => {
@@ -86,5 +87,5 @@ export function register(api) {
     req.on("error", (e) =>
       res.status(500).json({ ok: false, error: e.message })
     );
-  });
+  }));
 }