@ordewell/web 0.7.0 → 0.7.2

package/dist/server/main.js

@@ -103,7 +103,7 @@ var WebConfig = class extends core.BaseConfig {
     if (process.env.ORDEWELL_OPENCODE_ENABLED === "true" || process.env.ORDEWELL_OPENCODE_ENABLED === "1") {
       out.push("opencode");
     }
-    return out.length > 0 ? out : ["claude-code"];
+    return out.length > 0 ? out : [...core.DEFAULT_RUNNERS];
   }
 };
 function scanWorkspacesImpl(deps) {
@@ -416,10 +416,6 @@ var AdvisingRunner = class {
 var OrchestratorPool = class {
   sessions = /* @__PURE__ */ new Map();
   clients = /* @__PURE__ */ new Map();
-  /** The in-flight planning turn's abort controller, one per session — see `cancelPlanning`. */
-  planningAborts = /* @__PURE__ */ new Map();
-  /** Sessions whose planning slot a compaction holds; a reply must not take it over. */
-  compacting = /* @__PURE__ */ new Set();
   registry = (() => {
     const r = new core.RunnerRegistry();
     r.loadUserPlugins();
@@ -619,7 +615,11 @@ var OrchestratorPool = class {
         if (core.PROVIDER_CREDENTIAL_ENV.has(key)) touched = true;
       }
       if (envChanges.ORDEWELL_MAX_PARALLEL !== void 0) {
-        for (const session of this.sessions.values()) void session.reschedule();
+        for (const [id, session] of this.sessions) {
+          session.reschedule().catch((err) => {
+            console.error(`[web] reschedule failed for session ${id}: ${err instanceof Error ? err.message : err}`);
+          });
+        }
       }
       if (touched) {
         this.modelResolver.invalidate();
@@ -655,6 +655,7 @@ var OrchestratorPool = class {
     const rejectedEnvKeys = admission2?.rejected ?? [];
     const settings = this.getSettings();
     if (rejectedEnvKeys.length > 0) settings.rejectedEnvKeys = rejectedEnvKeys;
+    if (switchRecall) settings.switchRecall = switchRecall;
     return settings;
   }
   setOrchestratorModel(model) {
@@ -683,18 +684,7 @@ var OrchestratorPool = class {
         }
       }
     }
-    const providers = [];
-    for (const provider of core.PROVIDER_PRIORITY) {
-      if (provider === "openai_compatible") {
-        if (config.openaiCompatibleBaseUrl) providers.push(provider);
-      } else if (provider === "openrouter") {
-        if (config.openrouterKey) providers.push(provider);
-      } else if (provider === "google") {
-        if (config.geminiKey) providers.push(provider);
-      } else if (config.getProviderApiKey(provider)) {
-        providers.push(provider);
-      }
-    }
+    const providers = core.configuredProviders(config);
     return {
       models: allModels,
       modelsByRunner,
@@ -729,15 +719,9 @@ var OrchestratorPool = class {
   }
   async generatePlan(sessionId, goal, runners, workspace, modelOverride, options) {
     const session = this.createSessionFor(sessionId, workspace, modelOverride, options);
+    this.destroy(sessionId);
     this.sessions.set(sessionId, session);
-    const controller = new AbortController();
-    this.planningAborts.set(sessionId, controller);
-    try {
-      const plan = await session.generatePlan(goal, runners, { signal: controller.signal });
-      return core.migratePlanState(plan);
-    } finally {
-      this.clearPlanningAbort(sessionId, controller);
-    }
+    return core.migratePlanState(await session.generatePlan(goal, runners));
   }
   /**
    * Conversational planning (ADR-0002): start the planner dialogue for a
@@ -747,69 +731,27 @@ var OrchestratorPool = class {
    */
   async startPlanning(sessionId, goal, runners, workspace, modelOverride, options) {
     const session = this.createSessionFor(sessionId, workspace, modelOverride, options);
+    this.destroy(sessionId);
     this.sessions.set(sessionId, session);
-    const controller = new AbortController();
-    this.planningAborts.set(sessionId, controller);
-    try {
-      return await session.startPlanning(goal, runners, { signal: controller.signal });
-    } finally {
-      this.clearPlanningAbort(sessionId, controller);
-    }
+    return session.startPlanning(goal, runners);
   }
-  /**
-   * Continue the planner dialogue with the user's reply. Refused during a
-   * compaction before the abort slot is touched: the session refuses the reply
-   * too, but by then the compaction's controller would be gone and a stop could
-   * no longer reach its summary turn.
-   */
+  /** Continue the planner dialogue with the user's reply; refused while a planner turn is in flight. */
   async continuePlanning(sessionId, message) {
-    if (this.compacting.has(sessionId)) throw new core.ConversationBusyError("send a message");
-    const controller = new AbortController();
-    this.planningAborts.set(sessionId, controller);
-    try {
-      return await this.session(sessionId).continueConversation(message, { signal: controller.signal });
-    } finally {
-      this.clearPlanningAbort(sessionId, controller);
-    }
+    return this.session(sessionId).continueConversation(message);
   }
-  /**
-   * Condense a session's conversation. The summary turn is a planning turn as
-   * far as a surface is concerned, so it registers the same abort controller
-   * and `cancelPlanning` stops it — but only when no turn holds that slot
-   * already: taking it over would leave the reply in flight beyond stopping.
-   */
+  /** Condense a session's conversation. The summary turn is a planner turn, so `cancelPlanning` stops it. */
   async compactConversation(sessionId) {
     const session = this.session(sessionId);
-    if (this.planningAborts.has(sessionId)) throw new core.ConversationBusyError("condense the conversation");
-    const controller = new AbortController();
-    this.planningAborts.set(sessionId, controller);
-    this.compacting.add(sessionId);
-    try {
-      const compaction = await session.compactConversation(controller.signal);
-      return { ...compaction, plan: session.planState };
-    } finally {
-      this.compacting.delete(sessionId);
-      this.clearPlanningAbort(sessionId, controller);
-    }
+    const compaction = await session.compactConversation();
+    return { ...compaction, plan: session.planState };
   }
   /**
-   * Abort the planning turn in flight for a session, if any. Answers whether
+   * Abort the planner turn in flight for a session, if any. Answers whether
    * there was one to cancel — the route reports that rather than 404ing a
    * session that simply is not planning right now.
    */
   cancelPlanning(sessionId) {
-    const controller = this.planningAborts.get(sessionId);
-    if (!controller) return false;
-    controller.abort();
-    return true;
-  }
-  /**
-   * Only clears the map entry if it still holds the controller this turn
-   * created — a later turn may already have installed its own by the time
-   * this one's `finally` runs (a fresh request racing a slow abort).
-   */
-  clearPlanningAbort(sessionId, controller) {
-    if (this.planningAborts.get(sessionId) === controller) this.planningAborts.delete(sessionId);
+    return this.sessions.get(sessionId)?.abortPlannerTurn() ?? false;
   }
   /**
    * Register a session persisted on disk so its plan becomes executable and
@@ -824,9 +766,10 @@ var OrchestratorPool = class {
     const live = this.sessions.get(sessionId);
     if (live?.planState) return live.planState;
     const saved = core.loadSession(sessionId, workspace);
-    if (!saved) throw new Error("Session not found");
+    if (!saved) throw new core.SessionNotFoundError();
     const session = this.createSessionFor(sessionId, workspace);
     session.loadPlan(saved.plan, saved.meta.goal, workspace, { sessionId: saved.meta.id });
+    this.destroy(sessionId);
     this.sessions.set(sessionId, session);
     return session.planState ?? saved.plan;
   }
@@ -853,14 +796,10 @@ var OrchestratorPool = class {
    */
   session(sessionId) {
     const session = this.sessions.get(sessionId);
-    if (!session) throw new Error("Session not found");
+    if (!session) throw new core.SessionNotFoundError();
     return session;
   }
-  // The Session drops its planner context, but the model call in flight is
-  // the pool's to abort: it holds the only signal that reaches it.
   destroy(sessionId) {
-    this.planningAborts.get(sessionId)?.abort();
-    this.planningAborts.delete(sessionId);
     this.sessions.get(sessionId)?.destroy();
     this.sessions.delete(sessionId);
   }
@@ -875,6 +814,37 @@ function getSessionList(workspace) {
 function removeSession(sessionId, workspace) {
   return core.deleteSession(sessionId, workspace);
 }
+function classify(err) {
+  if (err instanceof core.SessionNotFoundError) return { status: 404, code: "session_not_found" };
+  if (err instanceof core.NoPlanError) return { status: 400, code: "no_plan" };
+  if (err instanceof core.AlreadyExecutingError) return { status: 409, code: "already_executing" };
+  if (err instanceof core.WorkspaceNotAProjectError) return { status: 400, code: "workspace_not_a_project" };
+  if (err instanceof core.WorkspaceNotFoundError) return { status: 400, code: "workspace_not_found" };
+  if (err instanceof core.PlannerTurnStoppedError) return { status: 409, code: "planner_turn_stopped" };
+  if (err instanceof core.PlannerTurnDiscardedError) return { status: 409, code: "planner_turn_discarded" };
+  if (err instanceof core.ConversationBusyError) return { status: 409, code: "conversation_busy" };
+  if (err instanceof core.ConversationEditError || err instanceof core.PlanEditError || err instanceof core.TaskControlError) {
+    return { status: 400, code: "refused" };
+  }
+  return void 0;
+}
+function refuse(c, status, message, code) {
+  const body = code ? { error: message, code } : { error: message };
+  return c.json(body, status);
+}
+function failure(c, err, label, { fallback = 500, message = "Internal error" } = {}) {
+  const classified = classify(err);
+  const status = classified?.status ?? fallback;
+  if (status >= 500) console.error(`[web] ${label} failed:`, err);
+  const body = {
+    error: err instanceof Error && err.message || message,
+    ...classified ? { code: classified.code } : {},
+    ...err instanceof core.WorkspaceNotAProjectError ? { workspace: err.workspace } : {}
+  };
+  return c.json(body, status);
+}
+
+// server/routes/sessions.ts
 function sessionsRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", (c) => {
@@ -886,7 +856,7 @@ function sessionsRoute(pool2) {
     const ws = c.req.query("workspace") || process.cwd();
     const id = c.req.param("id");
     const saved = core.loadSessionPlanState(id, ws);
-    if (!saved) return c.json({ error: "Session not found" }, 404);
+    if (!saved) return refuse(c, 404, "Session not found", "session_not_found");
     return c.json({ meta: saved.meta, plan: pool2.getPlanState(id) ?? saved.plan });
   });
   router.post("/:id/load", (c) => {
@@ -896,10 +866,7 @@ function sessionsRoute(pool2) {
       const plan = pool2.adoptSavedSession(id, ws);
       return c.json({ ok: true, plan, goal: pool2.getGoal(id) });
     } catch (err) {
-      if (err instanceof core.WorkspaceNotFoundError) return c.json({ error: err.message }, 400);
-      const message = err instanceof Error ? err.message : void 0;
-      const status = message === "Session not found" ? 404 : 500;
-      return c.json({ error: message ?? "Failed to load session" }, status);
+      return failure(c, err, "load session", { message: "Failed to load session" });
     }
   });
   router.get("/:id/tasks/:taskId/log", (c) => {
@@ -909,7 +876,7 @@ function sessionsRoute(pool2) {
   router.get("/:id/tasks/:taskId/log/:attempt", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
     const attempt = Number(c.req.param("attempt"));
-    if (!Number.isInteger(attempt) || attempt < 1) return c.json({ error: "attempt must be a positive integer" }, 400);
+    if (!Number.isInteger(attempt) || attempt < 1) return refuse(c, 400, "attempt must be a positive integer");
     return c.json({ attempt, events: core.readTaskLog({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId"), attempt) });
   });
   router.delete("/:id", (c) => {
@@ -923,21 +890,7 @@ function sessionsRoute(pool2) {
   });
   return router;
 }
-function editFailure(c, err) {
-  const e = err;
-  if (e.message === "Session not found") return c.json({ error: e.message }, 404);
-  if (e instanceof core.PlanEditError || e instanceof core.TaskControlError) return c.json({ error: e.message }, 400);
-  console.error("[plans] task edit failed:", err);
-  return c.json({ error: e.message || "Internal error" }, 500);
-}
-function conversationFailure(c, err) {
-  const e = err;
-  if (e.message === "Session not found") return c.json({ error: e.message }, 404);
-  if (e instanceof core.ConversationBusyError) return c.json({ error: e.message }, 409);
-  if (e instanceof core.ConversationEditError) return c.json({ error: e.message }, 400);
-  console.error("[plans] conversation edit failed:", err);
-  return c.json({ error: e.message || "Internal error" }, 500);
-}
+var NO_CHECKPOINT = "The task is not waiting at a checkpoint \u2014 it was answered already, withdrawn, or has no runner left to hear it.";
 function plansRoute(pool2) {
   const router = new hono.Hono();
   router.post("/:sessionId/generate", async (c) => {
@@ -951,12 +904,7 @@ function plansRoute(pool2) {
       const { models, modelsByRunner } = await pool2.getProviderModels();
       return c.json({ plan, models, modelsByRunner });
     } catch (err) {
-      if (err instanceof core.WorkspaceNotFoundError) return c.json({ error: err.message }, 400);
-      if (err instanceof core.WorkspaceNotAProjectError) {
-        return c.json({ error: err.message, code: "workspace_not_a_project", workspace: err.workspace }, 400);
-      }
-      console.error("[plans] generate failed:", err);
-      return c.json({ error: err instanceof Error ? err.message : "Plan generation failed" }, 500);
+      return failure(c, err, "generate", { message: "Plan generation failed" });
     }
   });
   router.post("/:sessionId/execute", async (c) => {
@@ -964,9 +912,7 @@ function plansRoute(pool2) {
       await pool2.session(c.req.param("sessionId")).executePlan();
       return c.json({ status: "running" });
     } catch (err) {
-      const e = err;
-      const status = e.message === "Session not found" ? 404 : e.message === "No plan to execute" ? 400 : e.message === "Session already executing" ? 409 : 500;
-      return c.json({ error: e.message }, status);
+      return failure(c, err, "execute");
     }
   });
   router.post("/:sessionId/stop", (c) => {
@@ -982,7 +928,7 @@ function plansRoute(pool2) {
       await pool2.session(c.req.param("sessionId")).markTaskComplete(c.req.param("taskId"));
       return c.json({ ok: true });
     } catch (err) {
-      return c.json({ error: err instanceof Error ? err.message : "Not found" }, 404);
+      return failure(c, err, "mark complete", { fallback: 404, message: "Not found" });
     }
   });
   router.post("/:sessionId/tasks/:taskId/uncomplete", async (c) => {
@@ -990,7 +936,7 @@ function plansRoute(pool2) {
       await pool2.session(c.req.param("sessionId")).markTaskIncomplete(c.req.param("taskId"));
       return c.json({ ok: true });
     } catch (err) {
-      return c.json({ error: err instanceof Error ? err.message : "Not found" }, 404);
+      return failure(c, err, "mark incomplete", { fallback: 404, message: "Not found" });
     }
   });
   for (const [segment, run2] of [
@@ -1004,20 +950,29 @@ function plansRoute(pool2) {
         await run2(pool2.session(c.req.param("sessionId")), c.req.param("taskId"));
         return c.json({ ok: true });
       } catch (err) {
-        const status = err.message === "Session not found" ? 404 : 500;
-        return c.json({ error: err.message }, status);
+        return failure(c, err, segment);
       }
     });
   }
-  router.post("/:sessionId/tasks/:taskId/messages", async (c) => {
+  const messageHandler = (send) => async (c) => {
     try {
       const body = await c.req.json().catch(() => ({}));
       const text = typeof body === "object" && body !== null && "text" in body ? body.text : void 0;
       if (typeof text !== "string" || !text.trim()) return c.json({ error: "text is required" }, 400);
-      const id = pool2.session(c.req.param("sessionId")).sendTaskMessage(c.req.param("taskId"), text);
+      const id = send(pool2.session(c.req.param("sessionId")), c.req.param("taskId"), text);
       return c.json({ id });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
+    }
+  };
+  router.post("/:sessionId/tasks/:taskId/messages", messageHandler((session, taskId, text) => session.sendTaskMessage(taskId, text)));
+  router.post("/:sessionId/tasks/:taskId/messages/now", messageHandler((session, taskId, text) => session.forceSendTaskMessage(taskId, text)));
+  router.post("/:sessionId/tasks/:taskId/messages/:messageId/now", (c) => {
+    try {
+      const sent = pool2.session(c.req.param("sessionId")).forceSendQueuedTaskMessage(c.req.param("taskId"), c.req.param("messageId"));
+      return c.json({ sent });
+    } catch (err) {
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/tasks/:taskId/continue", async (c) => {
@@ -1028,7 +983,7 @@ function plansRoute(pool2) {
       await pool2.session(c.req.param("sessionId")).continueTask(c.req.param("taskId"), text);
       return c.json({ ok: true });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.delete("/:sessionId/tasks/:taskId/messages/:messageId", (c) => {
@@ -1036,7 +991,7 @@ function plansRoute(pool2) {
       const removed = pool2.session(c.req.param("sessionId")).removeQueuedTaskMessage(c.req.param("taskId"), c.req.param("messageId"));
       return c.json({ removed });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/tasks/:taskId/interrupt", async (c) => {
@@ -1044,7 +999,31 @@ function plansRoute(pool2) {
       await pool2.session(c.req.param("sessionId")).interruptTask(c.req.param("taskId"));
       return c.json({ ok: true });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
+    }
+  });
+  router.post("/:sessionId/tasks/:taskId/checkpoint/approve", (c) => {
+    try {
+      const session = pool2.session(c.req.param("sessionId"));
+      const taskId = c.req.param("taskId");
+      if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
+      session.approveCheckpoint(taskId);
+      return c.json({ ok: true });
+    } catch (err) {
+      return failure(c, err, "task edit");
+    }
+  });
+  router.post("/:sessionId/tasks/:taskId/checkpoint/reject", async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const reason = typeof body === "object" && body !== null && "reason" in body && typeof body.reason === "string" ? body.reason.trim() : "";
+      const session = pool2.session(c.req.param("sessionId"));
+      const taskId = c.req.param("taskId");
+      if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
+      session.rejectCheckpoint(taskId, reason || void 0);
+      return c.json({ ok: true });
+    } catch (err) {
+      return failure(c, err, "task edit");
     }
   });
   router.get("/:sessionId/tasks/:taskId/merge-gate", (c) => {
@@ -1057,21 +1036,21 @@ function plansRoute(pool2) {
       });
       return c.json({ mergeGate });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.get("/:sessionId/isolation/diff", async (c) => {
     try {
       return c.json({ diff: await pool2.session(c.req.param("sessionId")).reviewRunDiff() });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/isolation/merge", async (c) => {
     try {
       return c.json(await pool2.session(c.req.param("sessionId")).mergeRun());
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   for (const [segment, run2] of [
@@ -1085,7 +1064,7 @@ function plansRoute(pool2) {
         await run2(pool2.session(c.req.param("sessionId")));
         return c.json({ ok: true });
       } catch (err) {
-        return editFailure(c, err);
+        return failure(c, err, "task edit");
       }
     });
   }
@@ -1094,7 +1073,7 @@ function plansRoute(pool2) {
       const plan = await pool2.session(c.req.param("sessionId")).resolveConflictAsTask(c.req.param("taskId"));
       return c.json({ plan });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.put("/:sessionId/tasks/:taskId", async (c) => {
@@ -1110,33 +1089,33 @@ function plansRoute(pool2) {
         try {
           result = await session.setTaskDependencies(taskId, dependencies.map(String));
         } catch (err) {
-          return c.json({ error: err.message }, 400);
+          return failure(c, err, "task dependencies", { fallback: 400 });
         }
       }
       if (Object.keys(rest).length > 0 || !hasRunner && !hasDeps) result = await session.updateTask(taskId, rest);
-      if (!result) return c.json({ error: "Task not found" }, 404);
+      if (!result) return refuse(c, 404, "Task not found", "task_not_found");
       return c.json({ ok: true });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.delete("/:sessionId/tasks/:taskId", async (c) => {
     try {
       const result = await pool2.session(c.req.param("sessionId")).removeTask(c.req.param("taskId"));
-      if (!result) return c.json({ error: "Task not found" }, 404);
+      if (!result) return refuse(c, 404, "Task not found", "task_not_found");
       return c.json({ ok: true });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/tasks", async (c) => {
     try {
       const body = await c.req.json();
       const result = await pool2.session(c.req.param("sessionId")).addTask(body);
-      if (!result) return c.json({ error: "Session not found" }, 404);
+      if (!result) return refuse(c, 404, "Session not found", "session_not_found");
       return c.json({ ok: true });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/review/approve", async (c) => {
@@ -1144,9 +1123,7 @@ function plansRoute(pool2) {
       const plan = await pool2.session(c.req.param("sessionId")).approveReview();
       return c.json({ plan });
     } catch (err) {
-      const e = err;
-      const status = e.message === "Session not found" ? 404 : e.message === "No plan to review" ? 400 : 500;
-      return c.json({ error: e.message }, status);
+      return failure(c, err, "review approve");
     }
   });
   router.post("/:sessionId/tasks/merge", async (c) => {
@@ -1158,9 +1135,7 @@ function plansRoute(pool2) {
       const plan = await pool2.session(c.req.param("sessionId")).requestMerge(taskIds);
       return c.json({ plan });
     } catch (err) {
-      const e = err;
-      const status = e.message === "Session not found" ? 404 : 400;
-      return c.json({ error: e.message }, status);
+      return failure(c, err, "merge", { fallback: 400 });
     }
   });
   router.post("/:sessionId/tasks/:taskId/split", async (c) => {
@@ -1168,9 +1143,7 @@ function plansRoute(pool2) {
       const plan = await pool2.session(c.req.param("sessionId")).requestSplit(c.req.param("taskId"));
       return c.json({ plan });
     } catch (err) {
-      const e = err;
-      const status = e.message === "Session not found" ? 404 : 400;
-      return c.json({ error: e.message }, status);
+      return failure(c, err, "split", { fallback: 400 });
     }
   });
   router.post("/:sessionId/converse/start", async (c) => {
@@ -1182,11 +1155,7 @@ function plansRoute(pool2) {
       const plan = await pool2.startPlanning(c.req.param("sessionId"), goal, runnerList, ws, model, { allowInit });
       return c.json({ plan });
     } catch (err) {
-      if (err instanceof core.WorkspaceNotFoundError) return c.json({ error: err.message }, 400);
-      if (err instanceof core.WorkspaceNotAProjectError) {
-        return c.json({ error: err.message, code: "workspace_not_a_project", workspace: err.workspace }, 400);
-      }
-      return c.json({ error: err instanceof Error ? err.message : "Planning failed" }, 500);
+      return failure(c, err, "converse start", { message: "Planning failed" });
     }
   });
   router.post("/:sessionId/converse/message", async (c) => {
@@ -1196,24 +1165,21 @@ function plansRoute(pool2) {
       const plan = await pool2.continuePlanning(c.req.param("sessionId"), message);
       return c.json({ plan });
     } catch (err) {
-      const e = err;
-      if (e instanceof core.ConversationBusyError) return c.json({ error: e.message }, 409);
-      const status = e.message === "Session not found" ? 404 : 500;
-      return c.json({ error: e.message }, status);
+      return failure(c, err, "conversation message");
     }
   });
   router.post("/:sessionId/conversation/fork", (c) => {
     try {
       return c.json(pool2.forkConversation(c.req.param("sessionId")));
     } catch (err) {
-      return conversationFailure(c, err);
+      return failure(c, err, "conversation edit");
     }
   });
   router.get("/:sessionId/conversation/rewind-targets", (c) => {
     try {
       return c.json({ targets: pool2.session(c.req.param("sessionId")).rewindTargets() });
     } catch (err) {
-      return conversationFailure(c, err);
+      return failure(c, err, "conversation edit");
     }
   });
   router.post("/:sessionId/conversation/rewind", async (c) => {
@@ -1222,29 +1188,19 @@ function plansRoute(pool2) {
       if (!Number.isInteger(index) || index < 0) return c.json({ error: "index must be a non-negative integer" }, 400);
       return c.json(pool2.rewindConversation(c.req.param("sessionId"), index));
     } catch (err) {
-      return conversationFailure(c, err);
+      return failure(c, err, "conversation edit");
     }
   });
   router.post("/:sessionId/conversation/compact", async (c) => {
     try {
       return c.json(await pool2.compactConversation(c.req.param("sessionId")));
     } catch (err) {
-      return conversationFailure(c, err);
-    }
-  });
-  router.post("/:sessionId/process-queued", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).processQueuedMessages();
-      return c.json({ ok: true });
-    } catch (err) {
-      const e = err;
-      const status = e.message === "Session not found" ? 404 : 500;
-      return c.json({ error: e.message }, status);
+      return failure(c, err, "conversation edit");
     }
   });
   router.get("/:sessionId/prd", (c) => {
     const plan = pool2.getPlan(c.req.param("sessionId"));
-    if (!plan?.prdMarkdown) return c.json({ error: "No PRD found" }, 404);
+    if (!plan?.prdMarkdown) return refuse(c, 404, "No PRD found");
     return c.json({ prdMarkdown: plan.prdMarkdown });
   });
   return router;
@@ -1295,7 +1251,7 @@ function approvalsRoute(pool2) {
   const router = new hono.Hono();
   router.get("/:sessionId", (c) => {
     const sessionId = c.req.param("sessionId");
-    if (!pool2.hasSession(sessionId)) return c.json({ error: `Unknown session: ${sessionId}` }, 404);
+    if (!pool2.hasSession(sessionId)) return refuse(c, 404, `Unknown session: ${sessionId}`, "session_not_found");
     return c.json({
       pending: pool2.outstandingApprovals(sessionId),
       approvedScopes: pool2.approvedScopes(sessionId)
@@ -1304,10 +1260,10 @@ function approvalsRoute(pool2) {
   router.post("/:sessionId/:approvalId", async (c) => {
     const sessionId = c.req.param("sessionId");
     const approvalId = c.req.param("approvalId");
-    if (!pool2.hasSession(sessionId)) return c.json({ error: `Unknown session: ${sessionId}` }, 404);
+    if (!pool2.hasSession(sessionId)) return refuse(c, 404, `Unknown session: ${sessionId}`, "session_not_found");
     const answer = answerOf(await c.req.json().catch(() => null));
     if (!pool2.resolveApproval(sessionId, approvalId, answer)) {
-      return c.json({ error: "Approval is no longer outstanding \u2014 it timed out or was already answered." }, 409);
+      return refuse(c, 409, "Approval is no longer outstanding \u2014 it timed out or was already answered.", "approval_not_outstanding");
     }
     const { decision } = core.toApprovalDecision(answer);
     return c.json({ ok: true, granted: core.isGranted({ decision }), decision });
@@ -1317,12 +1273,13 @@ function approvalsRoute(pool2) {
 function settingsRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", (c) => {
-    return c.json(pool2.getSettings());
+    const settings = pool2.getSettings();
+    return c.json(settings);
   });
   router.patch("/", async (c) => {
     const body = await c.req.json();
     if (!body || typeof body !== "object" || Object.keys(body).length === 0) {
-      return c.json({ error: "At least one setting field is required" }, 400);
+      return refuse(c, 400, "At least one setting field is required");
     }
     const result = pool2.updateSettings(body);
     return c.json(result);
@@ -1334,6 +1291,7 @@ var COMMANDS = [
   { name: "verify", description: "Toggle verification mode \u2014 adds a final evidence-based verification task that runs the full suite (on|off|status)" },
   { name: "transport", description: "Drive tasks through each runner's protocol (structured) or a terminal, from the next run (terminal|structured|status)" }
 ];
+var BOOLEAN_TOGGLES = { tdd: "tdd", verify: "verification" };
 function commandsRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", (c) => {
@@ -1345,23 +1303,15 @@ function commandsRoute(pool2) {
     const args2 = body?.args || {};
     const command = COMMANDS.find((cmd) => cmd.name === name);
     if (!command) {
-      return c.json({ error: `Unknown command: ${name}` }, 404);
+      return refuse(c, 404, `Unknown command: ${name}`);
     }
-    if (name === "tdd") {
+    const toggle = BOOLEAN_TOGGLES[name];
+    if (toggle) {
       const action = args2.action || "status";
       if (action === "on") {
-        pool2.updateSettings({ tdd: { enabled: true } });
+        pool2.updateSettings({ [toggle]: { enabled: true } });
       } else if (action === "off") {
-        pool2.updateSettings({ tdd: { enabled: false } });
-      }
-      return c.json({ ok: true, settings: pool2.getSettings() });
-    }
-    if (name === "verify") {
-      const action = args2.action || "status";
-      if (action === "on") {
-        pool2.updateSettings({ verification: { enabled: true } });
-      } else if (action === "off") {
-        pool2.updateSettings({ verification: { enabled: false } });
+        pool2.updateSettings({ [toggle]: { enabled: false } });
       }
       return c.json({ ok: true, settings: pool2.getSettings() });
     }
@@ -1370,11 +1320,11 @@ function commandsRoute(pool2) {
       if (action === "terminal" || action === "structured") {
         pool2.updateSettings({ runnerTransport: action });
       } else if (action !== "status") {
-        return c.json({ error: `Unknown transport: ${action} (terminal|structured)` }, 400);
+        return refuse(c, 400, `Unknown transport: ${action} (terminal|structured)`);
       }
       return c.json({ ok: true, settings: pool2.getSettings() });
     }
-    return c.json({ error: `Unknown command: ${name}` }, 404);
+    return refuse(c, 404, `Unknown command: ${name}`);
   });
   return router;
 }
@@ -1590,6 +1540,9 @@ async function shutdown() {
   server.close();
   process.exit(0);
 }
+process.on("unhandledRejection", (reason) => {
+  console.error(`[web] unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}`);
+});
 process.on("SIGINT", () => {
   shutdown();
 });