@ordewell/web 0.7.1 → 0.8.0

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) {
@@ -336,20 +336,22 @@ ${err}` : out;
     return { success: true, output: combined || "(no output)", truncated: combined.length > 2e4 };
   }
 };
+
+// server/adapters/PoolAwareRunner.ts
 var PoolAwareRunner = class {
   constructor(sessionId, broadcast, inner) {
     this.sessionId = sessionId;
     this.broadcast = broadcast;
-    this.inner = inner ?? new core.HeadlessRunner();
+    this.inner = inner;
   }
   sessionId;
   broadcast;
   inner;
   /**
-   * Sessions this plan spawned. The inner runner may be shared by every plan
-   * in the pool (one tmux session per daemon), so "stop everything" and
-   * "how many are running" must be answered from this set, never delegated —
-   * delegating would let one plan's /stop kill another plan's tasks.
+   * Sessions this plan spawned. The inner runner is shared by every plan in
+   * the pool, so "stop everything" and "how many are running" must be
+   * answered from this set, never delegated — delegating would let one plan's
+   * /stop kill another plan's tasks.
    */
   owned = /* @__PURE__ */ new Set();
   get activeCount() {
@@ -374,69 +376,22 @@ var PoolAwareRunner = class {
     this.owned.clear();
   }
 };
-var TMUX_MISSING_ADVICE = "tmux is not installed, so terminal-transport tasks run without a terminal window you can open or type into. Install tmux, or keep the structured transport (/transport structured).";
-function startTerminalHost(port2, deps = {}) {
-  const hasTmuxImpl = deps.hasTmuxImpl ?? core.hasTmux;
-  if (!hasTmuxImpl()) return { advice: TMUX_MISSING_ADVICE };
-  const runner = (deps.createTmuxRunner ?? ((p) => new core.TmuxRunner({ port: p })))(port2);
-  runner.ensureSession().catch((err) => {
-    console.error(`[web] tmux session setup failed (will retry on next task spawn): ${err?.message ?? err}`);
-  });
-  return { runner };
-}
-var AdvisingRunner = class {
-  constructor(inner, advice, advise) {
-    this.inner = inner;
-    this.advice = advice;
-    this.advise = advise;
-  }
-  inner;
-  advice;
-  advise;
-  advised = false;
-  get activeCount() {
-    return this.inner.activeCount;
-  }
-  spawn(opts) {
-    if (!this.advised) {
-      this.advised = true;
-      this.advise(this.advice);
-    }
-    return this.inner.spawn(opts);
-  }
-  stop(sessionId) {
-    this.inner.stop(sessionId);
-  }
-  stopAll() {
-    this.inner.stopAll();
-  }
-};
 
 // server/pool/orchestratorPool.ts
 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();
-    return r;
-  })();
+  registry = new core.RunnerRegistry();
   modelResolver;
   runnerInstallation = new core.RunnerInstallation(this.registry);
   cachedProviderLists;
   settingsService = new core.SettingsService();
   plannerModelMemory = new core.PlannerModelMemory(this.settingsService);
-  sharedRunner;
-  structuredRunner;
-  terminalAdvice;
+  runner;
   constructor(deps = {}) {
-    this.sharedRunner = deps.runner;
-    this.structuredRunner = deps.structuredRunner ?? new core.StructuredRunner();
-    this.terminalAdvice = deps.terminalAdvice;
+    const pluginNotice = core.removedPluginNotice();
+    if (pluginNotice) console.warn(pluginNotice);
+    this.runner = deps.runner ?? new core.StructuredRunner();
     this.modelResolver = deps.modelResolver ?? new core.ModelResolver(this.registry, new WebConfig());
   }
   subscribe(sessionId, ws) {
@@ -502,12 +457,7 @@ var OrchestratorPool = class {
     });
     const fsAdapter = new PoolFileSystem(workspace);
     const broadcast = (msg) => this.broadcast(sessionId, msg);
-    const terminal = this.sharedRunner ?? new core.HeadlessRunner();
-    const router = new core.TransportRouter({
-      terminal: this.terminalAdvice ? new AdvisingRunner(terminal, this.terminalAdvice, (message) => this.broadcast(sessionId, { type: "notice", level: "warn", message })) : terminal,
-      structured: this.structuredRunner
-    });
-    const runner = new PoolAwareRunner(sessionId, broadcast, router);
+    const runner = new PoolAwareRunner(sessionId, broadcast, this.runner);
     return core.createSession({
       config,
       notifications: { info() {
@@ -561,14 +511,10 @@ var OrchestratorPool = class {
       // for a planner that is running at "high".
       plannerThinkingEffort: config.plannerThinkingEffort ?? "",
       maxParallel: config.maxParallelSessions,
-      tdd: userSettings.tdd,
-      verification: userSettings.verification,
       modelAllowlist: userSettings.modelAllowlist,
       // The model remembered per planner backend (this task), so a surface can
       // render what's remembered without a second round-trip.
-      plannerModels: userSettings.plannerModels,
-      // ADR-0018; a run copies it when it starts.
-      runnerTransport: userSettings.runnerTransport
+      plannerModels: userSettings.plannerModels
     };
   }
   /**
@@ -596,22 +542,18 @@ var OrchestratorPool = class {
     const envChanges = admission2 ? admission2.accepted : void 0;
     const incomingAiProvider = typeof envChanges?.AI_PROVIDER === "string" ? envChanges.AI_PROVIDER : void 0;
     const switchedToProvider = incomingAiProvider && incomingAiProvider !== providerBefore ? incomingAiProvider : void 0;
-    const switchRecall = switchedToProvider ? this.plannerModelMemory.recall(switchedToProvider, this.plannerCatalogFor(switchedToProvider)) : void 0;
+    const requestedModel = envChanges?.ORCHESTRATOR_MODEL ?? changes.orchestratorModel;
+    const explicitModel = typeof requestedModel === "string" && requestedModel.trim().length > 0;
+    const switchRecall = switchedToProvider && !explicitModel ? this.plannerModelMemory.recall(switchedToProvider, this.plannerCatalogFor(switchedToProvider)) : void 0;
+    if (switchedToProvider && explicitModel && typeof changes.plannerThinkingEffort !== "string" && envChanges?.ORDEWELL_PLANNER_EFFORT === void 0) {
+      process.env.ORDEWELL_PLANNER_EFFORT = "";
+    }
     if (typeof changes.orchestratorModel === "string") {
       process.env.ORCHESTRATOR_MODEL = changes.orchestratorModel;
     }
     if (typeof changes.plannerThinkingEffort === "string") {
       process.env.ORDEWELL_PLANNER_EFFORT = changes.plannerThinkingEffort;
     }
-    if (changes.tdd && typeof changes.tdd.enabled === "boolean") {
-      this.settingsService.setTdd(changes.tdd.enabled);
-    }
-    if (changes.verification && typeof changes.verification.enabled === "boolean") {
-      this.settingsService.setVerification(changes.verification.enabled);
-    }
-    if (core.isRunnerTransport(changes.runnerTransport)) {
-      this.settingsService.setRunnerTransport(changes.runnerTransport);
-    }
     if (envChanges) {
       let touched = false;
       for (const [key, value] of Object.entries(envChanges)) {
@@ -619,7 +561,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();
@@ -640,7 +586,7 @@ var OrchestratorPool = class {
         }
       }
     }
-    const envCarriesModelOrEffort = envChanges?.AI_PROVIDER === void 0 && (typeof envChanges?.ORCHESTRATOR_MODEL === "string" || typeof envChanges?.ORDEWELL_PLANNER_EFFORT === "string");
+    const envCarriesModelOrEffort = (envChanges?.AI_PROVIDER === void 0 || explicitModel) && (typeof envChanges?.ORCHESTRATOR_MODEL === "string" || typeof envChanges?.ORDEWELL_PLANNER_EFFORT === "string");
     if (typeof changes.orchestratorModel === "string" || typeof changes.plannerThinkingEffort === "string" || envCarriesModelOrEffort) {
       const rememberProvider = switchedToProvider ?? new WebConfig({
         enabledRunners: this.enabledRunnerOverride(),
@@ -655,6 +601,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 +630,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,
@@ -717,11 +653,11 @@ var OrchestratorPool = class {
   async getInstalledRunners() {
     const config = new WebConfig({ enabledRunners: this.enabledRunnerOverride() });
     const enabled = new Set(config.enabledRunners);
-    const plugins = this.registry.list();
+    const runners = this.registry.list();
     const installedIds = new Set(
-      await this.runnerInstallation.filterInstalled(plugins.map((p) => p.manifest.name))
+      await this.runnerInstallation.filterInstalled(runners.map((p) => p.manifest.name))
     );
-    return plugins.filter((p) => installedIds.has(p.manifest.name)).map((p) => ({
+    return runners.filter((p) => installedIds.has(p.manifest.name)).map((p) => ({
       id: p.manifest.name,
       name: p.manifest.displayName,
       enabled: enabled.has(p.manifest.name)
@@ -729,15 +665,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 +677,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 +712,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 +742,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 +760,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,20 +802,17 @@ 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);
-    return c.json({ meta: saved.meta, plan: pool2.getPlanState(id) ?? saved.plan });
+    if (!saved) return refuse(c, 404, "Session not found", "session_not_found");
+    return c.json({ meta: saved.meta, plan: core.surfacePlanState(pool2.getPlanState(id) ?? saved.plan) });
   });
   router.post("/:id/load", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
     try {
       const id = c.req.param("id");
       const plan = pool2.adoptSavedSession(id, ws);
-      return c.json({ ok: true, plan, goal: pool2.getGoal(id) });
+      return c.json({ ok: true, plan: core.surfacePlan(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,8 +822,8 @@ 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);
-    return c.json({ attempt, events: core.readTaskLog({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId"), attempt) });
+    if (!Number.isInteger(attempt) || attempt < 1) return refuse(c, 400, "attempt must be a positive integer");
+    return c.json({ attempt, events: core.taskLogForSurface(core.readTaskLog({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId"), attempt)) });
   });
   router.delete("/:id", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
@@ -923,22 +836,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);
-}
 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 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);
-}
 function plansRoute(pool2) {
   const router = new hono.Hono();
   router.post("/:sessionId/generate", async (c) => {
@@ -950,14 +848,10 @@ function plansRoute(pool2) {
       const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : queryRunners ? queryRunners.split(",").map((s) => s.trim()).filter(Boolean) : pool2.getRunnerState().enabledRunners;
       const plan = await pool2.generatePlan(c.req.param("sessionId"), goal, runnerList, ws, model, { allowInit });
       const { models, modelsByRunner } = await pool2.getProviderModels();
-      return c.json({ plan, models, modelsByRunner });
+      const notes = (pool2.session(c.req.param("sessionId")).planState?.conversationHistory ?? []).filter((e) => e.kind === "system").map((e) => e.content);
+      return c.json({ plan: core.surfacePlanState(plan), models, modelsByRunner, ...notes.length > 0 ? { notes } : {} });
     } 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) => {
@@ -965,9 +859,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) => {
@@ -983,7 +875,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) => {
@@ -991,7 +883,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 [
@@ -1005,39 +897,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) => {
-    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);
-      return c.json({ id });
-    } catch (err) {
-      return editFailure(c, err);
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/messages/now", 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")).forceSendTaskMessage(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 editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/tasks/:taskId/continue", async (c) => {
@@ -1048,7 +930,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) => {
@@ -1056,7 +938,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) => {
@@ -1064,18 +946,18 @@ 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 c.json({ error: NO_CHECKPOINT }, 409);
+      if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
       session.approveCheckpoint(taskId);
       return c.json({ ok: true });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.post("/:sessionId/tasks/:taskId/checkpoint/reject", async (c) => {
@@ -1084,11 +966,11 @@ function plansRoute(pool2) {
       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 c.json({ error: NO_CHECKPOINT }, 409);
+      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 editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.get("/:sessionId/tasks/:taskId/merge-gate", (c) => {
@@ -1101,21 +983,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 [
@@ -1129,16 +1011,16 @@ 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");
       }
     });
   }
   router.post("/:sessionId/tasks/:taskId/resolve-conflict", async (c) => {
     try {
       const plan = await pool2.session(c.req.param("sessionId")).resolveConflictAsTask(c.req.param("taskId"));
-      return c.json({ plan });
+      return c.json({ plan: plan && core.surfacePlan(plan) });
     } catch (err) {
-      return editFailure(c, err);
+      return failure(c, err, "task edit");
     }
   });
   router.put("/:sessionId/tasks/:taskId", async (c) => {
@@ -1154,43 +1036,41 @@ 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) => {
     try {
       const plan = await pool2.session(c.req.param("sessionId")).approveReview();
-      return c.json({ plan });
+      return c.json({ plan: core.surfacePlan(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) => {
@@ -1200,21 +1080,17 @@ function plansRoute(pool2) {
         return c.json({ error: "taskIds array with at least two ids is required" }, 400);
       }
       const plan = await pool2.session(c.req.param("sessionId")).requestMerge(taskIds);
-      return c.json({ plan });
+      return c.json({ plan: core.surfacePlan(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) => {
     try {
       const plan = await pool2.session(c.req.param("sessionId")).requestSplit(c.req.param("taskId"));
-      return c.json({ plan });
+      return c.json({ plan: core.surfacePlan(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) => {
@@ -1224,13 +1100,9 @@ function plansRoute(pool2) {
       const ws = workspace || c.req.query("workspace") || process.cwd();
       const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : pool2.getRunnerState().enabledRunners;
       const plan = await pool2.startPlanning(c.req.param("sessionId"), goal, runnerList, ws, model, { allowInit });
-      return c.json({ plan });
+      return c.json({ plan: core.surfacePlan(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) => {
@@ -1238,57 +1110,47 @@ function plansRoute(pool2) {
       const { message } = await c.req.json();
       if (!message) return c.json({ error: "message is required" }, 400);
       const plan = await pool2.continuePlanning(c.req.param("sessionId"), message);
-      return c.json({ plan });
+      return c.json({ plan: core.surfacePlan(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")));
+      const fork = pool2.forkConversation(c.req.param("sessionId"));
+      return c.json({ ...fork, plan: core.surfacePlan(fork.plan) });
     } 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) => {
     try {
       const { index } = await c.req.json();
       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));
+      const rewound = pool2.rewindConversation(c.req.param("sessionId"), index);
+      return c.json({ ...rewound, plan: core.surfacePlan(rewound.plan) });
     } 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 });
+      const compacted = await pool2.compactConversation(c.req.param("sessionId"));
+      return c.json({ ...compacted, plan: core.surfacePlan(compacted.plan) });
     } 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;
@@ -1339,7 +1201,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)
@@ -1348,10 +1210,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 });
@@ -1361,64 +1223,28 @@ 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);
   });
   return router;
 }
-var COMMANDS = [
-  { name: "tdd", description: "Toggle Test-Driven Development mode (on|off|status)" },
-  { 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)" }
-];
-function commandsRoute(pool2) {
+var COMMANDS = [];
+function commandsRoute() {
   const router = new hono.Hono();
   router.get("/", (c) => {
     return c.json({ commands: COMMANDS });
   });
-  router.post("/:name", async (c) => {
+  router.post("/:name", (c) => {
     const name = c.req.param("name");
-    const body = await c.req.json().catch(() => ({}));
-    const args2 = body?.args || {};
-    const command = COMMANDS.find((cmd) => cmd.name === name);
-    if (!command) {
-      return c.json({ error: `Unknown command: ${name}` }, 404);
-    }
-    if (name === "tdd") {
-      const action = args2.action || "status";
-      if (action === "on") {
-        pool2.updateSettings({ tdd: { 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 } });
-      }
-      return c.json({ ok: true, settings: pool2.getSettings() });
-    }
-    if (name === "transport") {
-      const action = args2.action || "status";
-      if (action === "terminal" || action === "structured") {
-        pool2.updateSettings({ runnerTransport: action });
-      } else if (action !== "status") {
-        return c.json({ error: `Unknown transport: ${action} (terminal|structured)` }, 400);
-      }
-      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;
 }
@@ -1524,7 +1350,7 @@ function createApp(pool2, admission2) {
   app2.route("/api/runners", runnersRoute(pool2));
   app2.route("/api/models", modelsRoute(pool2));
   app2.route("/api/settings", settingsRoute(pool2));
-  app2.route("/api/commands", commandsRoute(pool2));
+  app2.route("/api/commands", commandsRoute());
   app2.route("/api/workspaces", workspacesRoute());
   app2.route("/api/approvals", approvalsRoute(pool2));
   return app2;
@@ -1612,10 +1438,9 @@ if (portIdx !== -1 && args[portIdx + 1]) {
 }
 var watchParentIdx = args.indexOf("--watch-parent");
 var watchParentPid = watchParentIdx !== -1 ? parseInt(args[watchParentIdx + 1], 10) : void 0;
-var { runner: tmuxRunner, advice: terminalAdvice } = startTerminalHost(port);
 var { token, file: tokenFile } = core.mintDaemonToken(port);
 var admission = { port, token, tokenFile };
-var pool = new OrchestratorPool({ runner: tmuxRunner, terminalAdvice, structuredRunner: new core.StructuredRunner() });
+var pool = new OrchestratorPool({ runner: new core.StructuredRunner() });
 var app = createApp(pool, admission);
 pool.getProviderModels().catch((err) => {
   console.error(`[web] model discovery warmup failed: ${err?.message ?? err}`);
@@ -1626,14 +1451,15 @@ attachWsHandler(server, pool, admission);
 server.listen(port, "127.0.0.1", () => {
   console.error(`[web] Ordewell API server: http://localhost:${port}`);
 });
-async function shutdown() {
+function shutdown() {
   core.clearDaemonToken(port);
   pool.destroyAll();
-  if (tmuxRunner) await tmuxRunner.killSession().catch(() => {
-  });
   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();
 });