@ordewell/web 0.9.1 → 0.10.0

package/dist/server/main.js

@@ -2,10 +2,10 @@
 'use strict';
 
 var hono = require('hono');
+var child_process = require('child_process');
 var core = require('@ordewell/core');
 var fs = require('fs');
 var path = require('path');
-var child_process = require('child_process');
 var ws = require('ws');
 var http = require('http');
 
@@ -304,17 +304,8 @@ var PoolFileSystem = class extends core.BaseFileSystem {
     };
   }
   async listDirImpl(absPath, depth) {
-    if (depth > 1) {
-      const result = await run("tree", ["-L", String(depth), "-I", "node_modules|.git|dist|build", absPath], { timeout: 1e4, env: this.searchEnv() });
-      if (result.code === 0 && result.stdout.trim()) {
-        const lines = result.stdout.trim().split("\n");
-        return { success: true, output: lines.slice(0, 300).join("\n"), truncated: lines.length > 300 };
-      }
-    }
     try {
-      const entries = await fs.promises.readdir(absPath, { withFileTypes: true });
-      const lines = entries.slice(0, 200).map((e) => `${e.isDirectory() ? "D" : "F"} ${e.name}`);
-      return { success: true, output: lines.join("\n") || "(empty directory)", truncated: entries.length > 200 };
+      return await core.listTree(absPath, depth, async (abs) => (await fs.promises.readdir(abs, { withFileTypes: true })).map((e) => ({ name: e.name, directory: e.isDirectory() })));
     } catch (err) {
       return { success: false, output: `Error listing ${absPath}: ${err.message}`, truncated: false };
     }
@@ -388,11 +379,22 @@ var OrchestratorPool = class {
   settingsService = new core.SettingsService();
   plannerModelMemory = new core.PlannerModelMemory(this.settingsService);
   runner;
+  /** One probe per daemon, asked again whenever the runner list is refreshed (ADR-0033). */
+  codexSandbox;
   constructor(deps = {}) {
     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());
+    this.codexSandbox = deps.codexSandbox ?? new core.CodexSandboxAvailability(this.registry, { spawn: child_process.spawn, fetch: globalThis.fetch }, { cwd: process.cwd(), env: process.env });
+  }
+  /**
+   * Not awaited: planning must start at once, and the daemon already warms the
+   * probe at startup through the catalog. This only covers a daemon that was
+   * asked to plan before that finished.
+   */
+  warmCodexSandbox() {
+    this.codexSandbox.ensure().catch((err) => console.error(`[web] codex sandbox probe failed: ${err instanceof Error ? err.message : err}`));
   }
   subscribe(sessionId, ws) {
     if (!this.clients.has(sessionId)) this.clients.set(sessionId, /* @__PURE__ */ new Set());
@@ -438,6 +440,10 @@ var OrchestratorPool = class {
   getGoal(sessionId) {
     return this.sessions.get(sessionId)?.currentGoal ?? "";
   }
+  /** Null for a session this process is not holding: there is no run to describe. */
+  runSnapshot(sessionId) {
+    return this.sessions.get(sessionId)?.runSnapshot() ?? null;
+  }
   runtimeSettings() {
     return core.sessionRuntimeSettings(this.settingsService.getAll());
   }
@@ -514,11 +520,23 @@ var OrchestratorPool = class {
       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
+      plannerModels: userSettings.plannerModels,
+      run: this.settingsService.getRunSettings()
     };
   }
   /**
-   * The catalog `PlannerModelMemory.recall` should judge `provider`'s
+   * Save the user's run settings, and apply them at once to `sessionId`'s run
+   * when that session is open here (ADR-0030). Other sessions' runs keep
+   * theirs. Throws a {@link RunSettingsError}, saving nothing, for a value
+   * out of range.
+   */
+  updateRunSettings(changes, sessionId) {
+    this.settingsService.updateRunSettings(changes);
+    if (sessionId) this.sessions.get(sessionId)?.applyRunSettings(changes);
+    return this.getSettings();
+  }
+  /**
+   * The catalog `selectPlanner` should judge `provider`'s
    * remembered model against — a harness planner's own runner catalog, or the
    * cross-provider picker list for a vendor (ADR-0009), same split as
    * `plannerModelItems` in the TUI reducer. Read from whatever the resolver
@@ -532,28 +550,32 @@ var OrchestratorPool = class {
     }
     return this.modelResolver.getCachedPickerOptions().map((o) => ({ id: o.id }));
   }
-  updateSettings(changes) {
-    const providerBefore = new WebConfig({
+  /**
+   * The provider planning right now. A vendor planner is resolved from its
+   * model id, so this is read again after a write rather than carried over.
+   */
+  plannerProviderInEffect() {
+    return new WebConfig({
       enabledRunners: this.enabledRunnerOverride(),
       providerModelLists: this.cachedProviderLists
     }).aiProvider;
+  }
+  updateSettings(changes) {
+    const current = {
+      provider: this.plannerProviderInEffect(),
+      model: process.env.ORCHESTRATOR_MODEL ?? "",
+      effort: process.env.ORDEWELL_PLANNER_EFFORT ?? ""
+    };
     const rawEnv = changes.env && typeof changes.env === "object" && !Array.isArray(changes.env) ? changes.env : void 0;
-    const admission2 = rawEnv ? core.admitSettingsEnv(rawEnv) : void 0;
-    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 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;
-    }
+    const admission = rawEnv ? core.admitSettingsEnv(rawEnv) : void 0;
+    const envChanges = admission ? admission.accepted : void 0;
+    const plannerChange = {
+      provider: envChanges?.AI_PROVIDER,
+      model: envChanges?.ORCHESTRATOR_MODEL ?? stringField(changes.orchestratorModel),
+      effort: envChanges?.ORDEWELL_PLANNER_EFFORT ?? stringField(changes.plannerThinkingEffort)
+    };
+    const touchesPlanner = Object.values(plannerChange).some((v) => v !== void 0);
+    const selection = touchesPlanner ? core.selectPlanner(current, plannerChange, this.plannerModelMemory, this.plannerCatalogFor(plannerChange.provider ?? current.provider)) : void 0;
     if (envChanges) {
       let touched = false;
       for (const [key, value] of Object.entries(envChanges)) {
@@ -572,9 +594,9 @@ var OrchestratorPool = class {
         this.modelResolver.refreshRunnerModels();
       }
     }
-    if (switchRecall) {
-      process.env.ORCHESTRATOR_MODEL = switchRecall.model;
-      process.env.ORDEWELL_PLANNER_EFFORT = switchRecall.effort;
+    if (selection) {
+      process.env.ORCHESTRATOR_MODEL = selection.next.model;
+      process.env.ORDEWELL_PLANNER_EFFORT = selection.next.effort;
     }
     if (changes.modelAllowlist && typeof changes.modelAllowlist === "object") {
       const allowlist = changes.modelAllowlist;
@@ -586,22 +608,15 @@ var OrchestratorPool = class {
         }
       }
     }
-    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(),
-        providerModelLists: this.cachedProviderLists
-      }).aiProvider;
-      this.plannerModelMemory.remember(
-        rememberProvider,
-        process.env.ORCHESTRATOR_MODEL || "",
-        process.env.ORDEWELL_PLANNER_EFFORT || ""
-      );
+    if (selection?.remember) {
+      const { provider, model, effort } = selection.remember;
+      const switched = provider !== current.provider;
+      this.plannerModelMemory.remember(switched ? provider : this.plannerProviderInEffect(), model, effort);
     }
-    const rejectedEnvKeys = admission2?.rejected ?? [];
+    const rejectedEnvKeys = admission?.rejected ?? [];
     const settings = this.getSettings();
     if (rejectedEnvKeys.length > 0) settings.rejectedEnvKeys = rejectedEnvKeys;
-    if (switchRecall) settings.switchRecall = switchRecall;
+    if (selection?.recall) settings.switchRecall = selection.recall;
     return settings;
   }
   setOrchestratorModel(model) {
@@ -613,7 +628,8 @@ var OrchestratorPool = class {
     const runnerIds = this.registry.list().map((p) => p.manifest.name);
     const [runnerModels, providerLists] = await Promise.all([
       this.modelResolver.modelsForRunners(runnerIds),
-      this.modelResolver.refresh()
+      this.modelResolver.refresh(),
+      this.codexSandbox.ensure()
     ]);
     const orchestratorModels = await this.modelResolver.pickerOptions();
     const providerErrors = this.modelResolver.getDiscoveryErrors();
@@ -653,6 +669,7 @@ var OrchestratorPool = class {
   async getInstalledRunners() {
     const config = new WebConfig({ enabledRunners: this.enabledRunnerOverride() });
     const enabled = new Set(config.enabledRunners);
+    await this.codexSandbox.refresh();
     const runners = this.registry.list();
     const installedIds = new Set(
       await this.runnerInstallation.filterInstalled(runners.map((p) => p.manifest.name))
@@ -667,6 +684,7 @@ var OrchestratorPool = class {
     const session = this.createSessionFor(sessionId, workspace, modelOverride, options);
     this.destroy(sessionId);
     this.sessions.set(sessionId, session);
+    this.warmCodexSandbox();
     return core.migratePlanState(await session.generatePlan(goal, runners));
   }
   /**
@@ -679,6 +697,7 @@ var OrchestratorPool = class {
     const session = this.createSessionFor(sessionId, workspace, modelOverride, options);
     this.destroy(sessionId);
     this.sessions.set(sessionId, session);
+    this.warmCodexSandbox();
     return session.startPlanning(goal, runners);
   }
   /** Continue the planner dialogue with the user's reply; refused while a planner turn is in flight. */
@@ -760,6 +779,9 @@ function getSessionList(workspace) {
 function removeSession(sessionId, workspace) {
   return core.deleteSession(sessionId, workspace);
 }
+function stringField(value) {
+  return typeof value === "string" ? value : void 0;
+}
 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" };
@@ -827,7 +849,9 @@ function sessionsRoute(pool2) {
   });
   router.delete("/:id", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
-    const ok = removeSession(c.req.param("id"), ws);
+    const id = c.req.param("id");
+    pool2.destroy(id);
+    const ok = removeSession(id, ws);
     return c.json({ ok });
   });
   router.post("/:id/close", (c) => {
@@ -837,6 +861,11 @@ function sessionsRoute(pool2) {
   return router;
 }
 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.";
+async function runUserCommand(session, command) {
+  const outcome = await session.execute(command, { kind: "user" });
+  if (!outcome.ok) throw new core.TaskControlError(outcome.message);
+  return outcome;
+}
 function plansRoute(pool2) {
   const router = new hono.Hono();
   router.post("/:sessionId/generate", async (c) => {
@@ -856,15 +885,24 @@ function plansRoute(pool2) {
   });
   router.post("/:sessionId/execute", async (c) => {
     try {
-      await pool2.session(c.req.param("sessionId")).executePlan();
+      const session = pool2.session(c.req.param("sessionId"));
+      if (!session.planState || session.planTasks.length === 0) throw new core.NoPlanError("execute");
+      if (session.isExecuting) throw new core.AlreadyExecutingError();
+      await runUserCommand(session, { command: "run_plan" });
       return c.json({ status: "running" });
     } catch (err) {
       return failure(c, err, "execute");
     }
   });
-  router.post("/:sessionId/stop", (c) => {
-    if (pool2.hasSession(c.req.param("sessionId"))) pool2.session(c.req.param("sessionId")).stopExecution();
-    return c.json({ status: "stopped" });
+  router.post("/:sessionId/stop", async (c) => {
+    try {
+      if (pool2.hasSession(c.req.param("sessionId"))) {
+        await pool2.session(c.req.param("sessionId")).execute({ command: "stop_run" }, { kind: "user" });
+      }
+      return c.json({ status: "stopped" });
+    } catch (err) {
+      return failure(c, err, "stop");
+    }
   });
   router.post("/:sessionId/planning/stop", (c) => {
     const cancelled = pool2.cancelPlanning(c.req.param("sessionId"));
@@ -886,34 +924,79 @@ function plansRoute(pool2) {
       return failure(c, err, "mark incomplete", { fallback: 404, message: "Not found" });
     }
   });
-  for (const [segment, run2] of [
-    ["run", (s, id) => s.runTask(id)],
-    ["force-start", (s, id) => s.forceStartTask(id)],
-    ["retry", (s, id) => s.retryTask(id)],
-    ["cancel", (s, id) => s.cancelTask(id)]
+  router.post("/:sessionId/tasks/:taskId/resume/cancel", (c) => {
+    try {
+      const cancelled = pool2.session(c.req.param("sessionId")).cancelScheduledResume(c.req.param("taskId"));
+      return c.json({ cancelled });
+    } catch (err) {
+      return failure(c, err, "cancel resume", { fallback: 404, message: "Not found" });
+    }
+  });
+  router.post("/:sessionId/tasks/:taskId/resume/now", async (c) => {
+    try {
+      await pool2.session(c.req.param("sessionId")).resumeNow(c.req.param("taskId"));
+      return c.json({ ok: true });
+    } catch (err) {
+      return failure(c, err, "resume now", { fallback: 404, message: "Not found" });
+    }
+  });
+  for (const [segment, command] of [
+    ["run", (id) => ({ command: "run_task", task: id })],
+    ["retry", (id) => ({ command: "retry_task", task: id, from: "fresh" })],
+    ["cancel", (id) => ({ command: "stop_task", task: id })]
   ]) {
     router.post(`/:sessionId/tasks/:taskId/${segment}`, async (c) => {
       try {
-        await run2(pool2.session(c.req.param("sessionId")), c.req.param("taskId"));
+        await runUserCommand(pool2.session(c.req.param("sessionId")), command(c.req.param("taskId")));
         return c.json({ ok: true });
       } catch (err) {
         return failure(c, err, segment);
       }
     });
   }
+  router.post("/:sessionId/tasks/:taskId/skip", 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 : void 0;
+      await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "skip_task", task: c.req.param("taskId"), ...reason ? { reason } : {} });
+      return c.json({ ok: true });
+    } catch (err) {
+      return failure(c, err, "skip");
+    }
+  });
+  router.post("/:sessionId/tasks/:taskId/force-start", async (c) => {
+    try {
+      await pool2.session(c.req.param("sessionId")).forceStartTask(c.req.param("taskId"));
+      return c.json({ ok: true });
+    } catch (err) {
+      return failure(c, err, "force-start");
+    }
+  });
   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 = send(pool2.session(c.req.param("sessionId")), c.req.param("taskId"), text);
+      const id = await send(pool2.session(c.req.param("sessionId")), c.req.param("taskId"), text);
       return c.json({ id });
     } catch (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", messageHandler(async (session, taskId, text) => (await runUserCommand(session, { command: "message_task", task: taskId, text })).id ?? ""));
   router.post("/:sessionId/tasks/:taskId/messages/now", messageHandler((session, taskId, text) => session.forceSendTaskMessage(taskId, text)));
+  router.post("/:sessionId/tasks/:taskId/commands", async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const fields = typeof body === "object" && body !== null ? body : {};
+      if (typeof fields.name !== "string" || !fields.name.trim()) return c.json({ error: "name is required" }, 400);
+      const args2 = typeof fields.args === "string" ? fields.args : "";
+      const id = pool2.session(c.req.param("sessionId")).invokeTaskCommand(c.req.param("taskId"), fields.name.trim(), args2);
+      return c.json({ id });
+    } catch (err) {
+      return failure(c, err, "task edit");
+    }
+  });
   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"));
@@ -927,7 +1010,7 @@ function plansRoute(pool2) {
       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);
-      await pool2.session(c.req.param("sessionId")).continueTask(c.req.param("taskId"), text);
+      await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "retry_task", task: c.req.param("taskId"), from: "session", message: text });
       return c.json({ ok: true });
     } catch (err) {
       return failure(c, err, "task edit");
@@ -1115,6 +1198,16 @@ function plansRoute(pool2) {
       return failure(c, err, "conversation message");
     }
   });
+  router.post("/:sessionId/converse/message/now", async (c) => {
+    try {
+      const { message } = await c.req.json();
+      if (!message) return c.json({ error: "message is required" }, 400);
+      const plan = await pool2.session(c.req.param("sessionId")).forceSendPrompt(message);
+      return c.json({ plan: core.surfacePlan(plan) });
+    } catch (err) {
+      return failure(c, err, "conversation message");
+    }
+  });
   router.post("/:sessionId/conversation/fork", (c) => {
     try {
       const fork = pool2.forkConversation(c.req.param("sessionId"));
@@ -1212,11 +1305,18 @@ function approvalsRoute(pool2) {
     const approvalId = c.req.param("approvalId");
     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)) {
+    const decided = core.toApprovalDecision(answer);
+    const request = pool2.outstandingApprovals(sessionId).find((pending) => pending.id === approvalId)?.request;
+    if (decided.decision === "deny" && request?.taskId) {
+      const outcome = await pool2.session(sessionId).execute(
+        { command: "answer_approval", task: request.taskId, approval: approvalId, answer: "deny", ...decided.note ? { note: decided.note } : {} },
+        { kind: "user" }
+      );
+      if (!outcome.ok) return refuse(c, 400, outcome.message, "refused");
+    } else if (!pool2.resolveApproval(sessionId, approvalId, answer)) {
       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 });
+    return c.json({ ok: true, granted: core.isGranted(decided), decision: decided.decision });
   });
   return router;
 }
@@ -1228,10 +1328,21 @@ function settingsRoute(pool2) {
   });
   router.patch("/", async (c) => {
     const body = await c.req.json();
-    if (!body || typeof body !== "object" || Object.keys(body).length === 0) {
+    if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length === 0) {
       return refuse(c, 400, "At least one setting field is required");
     }
-    const result = pool2.updateSettings(body);
+    const { run: run2, sessionId, ...rest } = body;
+    if (run2 !== void 0) {
+      if (!run2 || typeof run2 !== "object" || Array.isArray(run2)) return refuse(c, 400, "run must be an object of run settings");
+      if (sessionId !== void 0 && typeof sessionId !== "string") return refuse(c, 400, "sessionId must be a string");
+      try {
+        pool2.updateRunSettings(run2, sessionId);
+      } catch (err) {
+        if (err instanceof core.RunSettingsError) return refuse(c, 400, err.message);
+        throw err;
+      }
+    }
+    const result = Object.keys(rest).length > 0 ? pool2.updateSettings(rest) : pool2.getSettings();
     return c.json(result);
   });
   return router;
@@ -1266,6 +1377,8 @@ function createWsHandler(pool2) {
       pool2.unsubscribe(sessionId, ws);
     });
     ws.send(JSON.stringify({ type: "connected", sessionId }));
+    const view = pool2.runSnapshot(sessionId);
+    if (view) ws.send(JSON.stringify({ type: "run_snapshot", sessionId, view }));
     pool2.subscribe(sessionId, ws);
   });
   return (request, socket, head) => {
@@ -1331,9 +1444,9 @@ function withPort(hostname, port2) {
 }
 
 // server/app.ts
-function createApp(pool2, admission2) {
-  const app2 = new hono.Hono();
-  app2.use("*", async (c, next) => {
+function createApp(pool2, admission) {
+  const app = new hono.Hono();
+  app.use("*", async (c, next) => {
     const decision = decideAdmission({
       origin: c.req.header("origin") ?? null,
       // The request URL's authority is built from the Host header upstream, so
@@ -1341,21 +1454,21 @@ function createApp(pool2, admission2) {
       // absent entirely, which fails the check anyway.
       host: c.req.header("host") ?? new URL(c.req.url).host,
       authorization: c.req.header("authorization") ?? null
-    }, admission2);
+    }, admission);
     if (!decision.admit) return c.json({ error: decision.reason }, decision.status);
     await next();
   });
-  app2.route("/api/sessions", sessionsRoute(pool2));
-  app2.route("/api/plans", plansRoute(pool2));
-  app2.route("/api/runners", runnersRoute(pool2));
-  app2.route("/api/models", modelsRoute(pool2));
-  app2.route("/api/settings", settingsRoute(pool2));
-  app2.route("/api/commands", commandsRoute());
-  app2.route("/api/workspaces", workspacesRoute());
-  app2.route("/api/approvals", approvalsRoute(pool2));
-  return app2;
+  app.route("/api/sessions", sessionsRoute(pool2));
+  app.route("/api/plans", plansRoute(pool2));
+  app.route("/api/runners", runnersRoute(pool2));
+  app.route("/api/models", modelsRoute(pool2));
+  app.route("/api/settings", settingsRoute(pool2));
+  app.route("/api/commands", commandsRoute());
+  app.route("/api/workspaces", workspacesRoute());
+  app.route("/api/approvals", approvalsRoute(pool2));
+  return app;
 }
-function attachWsHandler(server2, pool2, admission2) {
+function attachWsHandler(server2, pool2, admission) {
   const handler = createWsHandler(pool2);
   server2.on("upgrade", (request, socket, head) => {
     const decision = decideAdmission({
@@ -1363,7 +1476,7 @@ function attachWsHandler(server2, pool2, admission2) {
       host: request.headers.host ?? null,
       authorization: request.headers.authorization ?? null,
       secWebSocketProtocol: request.headers["sec-websocket-protocol"] ?? null
-    }, admission2);
+    }, admission);
     if (!decision.admit) {
       refuseUpgrade(socket, decision);
       return;
@@ -1391,7 +1504,7 @@ ${body}`
 }
 
 // server/nodeAdapter.ts
-function createRequestListener(app2) {
+function createRequestListener(app) {
   return async (req, res) => {
     const bufs = [];
     for await (const chunk of req) bufs.push(chunk);
@@ -1411,7 +1524,7 @@ function createRequestListener(app2) {
       body: req.method !== "GET" && req.method !== "HEAD" ? body : void 0
     });
     try {
-      const webRes = await app2.fetch(webReq);
+      const webRes = await app.fetch(webReq);
       res.writeHead(webRes.status, Object.fromEntries(webRes.headers.entries()));
       if (webRes.body) {
         const reader = webRes.body.getReader();
@@ -1438,21 +1551,24 @@ if (portIdx !== -1 && args[portIdx + 1]) {
 }
 var watchParentIdx = args.indexOf("--watch-parent");
 var watchParentPid = watchParentIdx !== -1 ? parseInt(args[watchParentIdx + 1], 10) : void 0;
-var { token, file: tokenFile } = core.mintDaemonToken(port);
-var admission = { port, token, tokenFile };
 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}`);
-});
-app.get("/", (c) => c.json({ message: "Ordewell API", docs: "/api/workspaces" }));
-var server = http.createServer(createRequestListener(app));
-attachWsHandler(server, pool, admission);
+var server = http.createServer();
+var ownsToken = false;
 server.listen(port, "127.0.0.1", () => {
+  const { token, file: tokenFile } = core.mintDaemonToken(port);
+  ownsToken = true;
+  const admission = { port, token, tokenFile };
+  const app = createApp(pool, admission);
+  app.get("/", (c) => c.json({ message: "Ordewell API", docs: "/api/workspaces" }));
+  server.on("request", createRequestListener(app));
+  attachWsHandler(server, pool, admission);
+  pool.getProviderModels().catch((err) => {
+    console.error(`[web] model discovery warmup failed: ${err?.message ?? err}`);
+  });
   console.error(`[web] Ordewell API server: http://localhost:${port}`);
 });
 function shutdown() {
-  core.clearDaemonToken(port);
+  if (ownsToken) core.clearDaemonToken(port);
   pool.destroyAll();
   server.close();
   process.exit(0);