@ordewell/web 0.10.5 → 0.10.7

package/dist/server/main.js

@@ -922,27 +922,29 @@ function sessionsRoute(pool2) {
     const id = c.req.param("id");
     const saved = core.loadSessionPlanState(id, ws);
     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) });
+    const run2 = pool2.runSnapshot(id);
+    return c.json({ meta: saved.meta, plan: core.surfacePlanState(pool2.getPlanState(id) ?? saved.plan), ...run2 ? { run: run2 } : {} });
   });
   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: core.surfacePlan(plan), goal: pool2.getGoal(id) });
+      const run2 = pool2.runSnapshot(id);
+      return c.json({ ok: true, plan: core.surfacePlan(plan), goal: pool2.getGoal(id), ...run2 ? { run: run2 } : {} });
     } catch (err) {
       return failure(c, err, "load session", { message: "Failed to load session" });
     }
   });
   router.get("/:id/tasks/:taskId/log", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
-    return c.json({ attempts: core.listTaskLogAttempts({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId")) });
+    return c.json({ attempts: core.listTaskLogAttempts({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId")), position: pool2.streamPosition(c.req.param("id")) });
   });
   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 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)) });
+    return c.json({ attempt, events: core.taskLogForSurface(core.readTaskLog({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId"), attempt)), position: pool2.streamPosition(c.req.param("id")) });
   });
   router.delete("/:id", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
@@ -958,6 +960,9 @@ function sessionsRoute(pool2) {
   return router;
 }
 var NO_CHECKPOINT = "The task is not waiting at a checkpoint: it was answered already, withdrawn, or has no runner left to hear it.";
+function idOfRef(session, ref) {
+  return core.resolveUserTaskRef(session.planState?.tasks ?? [], ref)?.id ?? ref;
+}
 async function runUserCommand(session, command) {
   const outcome = await session.execute(command, { kind: "user" });
   if (!outcome.ok) throw new core.TaskControlError(outcome.message);
@@ -984,8 +989,8 @@ function plansRoute(pool2) {
     try {
       const session = pool2.session(c.req.param("sessionId"));
       if (!session.planState || session.planTasks.length === 0) throw new core.NoPlanError("execute");
-      await runUserCommand(session, { command: "run_plan" });
-      return c.json({ status: "running" });
+      const { message } = await runUserCommand(session, { command: "run_plan" });
+      return c.json({ status: "running", message });
     } catch (err) {
       return failure(c, err, "execute");
     }
@@ -996,6 +1001,7 @@ function plansRoute(pool2) {
         const session = pool2.session(c.req.param("sessionId"));
         const outcome = await session.execute({ command: "stop_run" }, { kind: "user" });
         if (!outcome.ok && (session.isExecuting || session.startsPending)) throw new core.TaskControlError(outcome.message);
+        return c.json({ status: "stopped", message: outcome.message });
       }
       return c.json({ status: "stopped" });
     } catch (err) {
@@ -1006,47 +1012,28 @@ function plansRoute(pool2) {
     const cancelled = pool2.cancelPlanning(c.req.param("sessionId"));
     return c.json({ cancelled });
   });
-  router.post("/:sessionId/tasks/:taskId/complete", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).markTaskComplete(c.req.param("taskId"));
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "mark complete", { fallback: 404, message: "Not found" });
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/uncomplete", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).markTaskIncomplete(c.req.param("taskId"));
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "mark incomplete", { fallback: 404, message: "Not found" });
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/resume/cancel", (c) => {
+  router.post("/:sessionId/tasks/:taskId/resume/cancel", async (c) => {
     try {
-      const cancelled = pool2.session(c.req.param("sessionId")).cancelScheduledResume(c.req.param("taskId"));
-      return c.json({ cancelled });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "cancel_resume", task: c.req.param("taskId") });
+      return c.json({ cancelled: true, message });
     } 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" });
+      return failure(c, err, "cancel resume");
     }
   });
   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 })]
+    ["cancel", (id) => ({ command: "stop_task", task: id })],
+    ["complete", (id) => ({ command: "mark_complete", task: id })],
+    ["uncomplete", (id) => ({ command: "mark_not_done", task: id })],
+    // The user says the limit has reset early: the task, and every other one waiting on its runner's reset, resumes in its saved session now.
+    ["resume/now", (id) => ({ command: "retry_task", task: id, from: "session" })],
+    ["interrupt", (id) => ({ command: "interrupt_task", task: id })]
   ]) {
     router.post(`/:sessionId/tasks/:taskId/${segment}`, async (c) => {
       try {
-        await runUserCommand(pool2.session(c.req.param("sessionId")), command(c.req.param("taskId")));
-        return c.json({ ok: true });
+        const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), command(c.req.param("taskId")));
+        return c.json({ ok: true, message });
       } catch (err) {
         return failure(c, err, segment);
       }
@@ -1056,16 +1043,16 @@ function plansRoute(pool2) {
     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 });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "skip_task", task: c.req.param("taskId"), ...reason ? { reason } : {} });
+      return c.json({ ok: true, message });
     } catch (err) {
       return failure(c, err, "skip");
     }
   });
   router.post("/:sessionId/tasks/:taskId/force-start", async (c) => {
     try {
-      const queued = await pool2.session(c.req.param("sessionId")).forceStartTask(c.req.param("taskId"));
-      return c.json({ ok: true, ...queued ? { queued } : {} });
+      const { message, payload } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "force_start", task: c.req.param("taskId") });
+      return c.json({ ok: true, ...payload?.kind === "queued" ? { queued: payload.line } : {}, message });
     } catch (err) {
       return failure(c, err, "force-start");
     }
@@ -1081,8 +1068,12 @@ function plansRoute(pool2) {
       return failure(c, err, "task edit");
     }
   };
-  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)));
+  const sendMessage = (force) => messageHandler(async (session, taskId, text) => {
+    const { payload } = await runUserCommand(session, { command: "message_task", task: taskId, text, ...force ? { force } : {} });
+    return payload?.kind === "message" ? payload.id : "";
+  });
+  router.post("/:sessionId/tasks/:taskId/messages", sendMessage(false));
+  router.post("/:sessionId/tasks/:taskId/messages/now", sendMessage(true));
   router.post("/:sessionId/tasks/:taskId/commands", async (c) => {
     try {
       const body = await c.req.json().catch(() => ({}));
@@ -1095,10 +1086,10 @@ function plansRoute(pool2) {
       return failure(c, err, "task edit");
     }
   });
-  router.post("/:sessionId/tasks/:taskId/messages/:messageId/now", (c) => {
+  router.post("/:sessionId/tasks/:taskId/messages/:messageId/now", async (c) => {
     try {
-      const sent = pool2.session(c.req.param("sessionId")).forceSendQueuedTaskMessage(c.req.param("taskId"), c.req.param("messageId"));
-      return c.json({ sent });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "force_send_queued", task: c.req.param("taskId"), id: c.req.param("messageId") });
+      return c.json({ sent: true, message });
     } catch (err) {
       return failure(c, err, "task edit");
     }
@@ -1108,57 +1099,40 @@ 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 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");
-    }
-  });
-  router.delete("/:sessionId/tasks/:taskId/messages/:messageId", (c) => {
-    try {
-      const removed = pool2.session(c.req.param("sessionId")).removeQueuedTaskMessage(c.req.param("taskId"), c.req.param("messageId"));
-      return c.json({ removed });
-    } catch (err) {
-      return failure(c, err, "task edit");
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/interrupt", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).interruptTask(c.req.param("taskId"));
-      return c.json({ ok: true });
+      const { message } = 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, message });
     } catch (err) {
       return failure(c, err, "task edit");
     }
   });
-  router.post("/:sessionId/tasks/:taskId/checkpoint/approve", (c) => {
+  router.delete("/:sessionId/tasks/:taskId/messages/:messageId", async (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 });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "remove_queued", task: c.req.param("taskId"), id: c.req.param("messageId") });
+      return c.json({ removed: true, message });
     } catch (err) {
       return failure(c, err, "task edit");
     }
   });
+  for (const answer of ["approve", "reject"]) {
+    router.post(`/:sessionId/tasks/:taskId/checkpoint/${answer}`, async (c) => {
+      try {
+        const body = answer === "reject" ? 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 = idOfRef(session, c.req.param("taskId"));
+        if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
+        const { message } = await runUserCommand(session, { command: "answer_checkpoint", task: taskId, answer, ...reason ? { reason } : {} });
+        return c.json({ ok: true, message });
+      } catch (err) {
+        return failure(c, err, "task edit");
+      }
+    });
+  }
   router.get("/:sessionId/tasks/:taskId/merge-gate", (c) => {
     try {
       const session = pool2.session(c.req.param("sessionId"));
       const tasks = core.flattenTasks(session.planState?.tasks ?? []);
-      const mergeGate = session.mergeGate(c.req.param("taskId")).map((id) => {
+      const mergeGate = session.mergeGate(idOfRef(session, c.req.param("taskId"))).map((id) => {
         const dep = tasks.find((t) => t.id === id);
         return { id, order: dep?.order ?? 0, title: dep?.title ?? id };
       });
@@ -1176,7 +1150,10 @@ function plansRoute(pool2) {
   });
   router.post("/:sessionId/isolation/merge", async (c) => {
     try {
-      return c.json(await pool2.session(c.req.param("sessionId")).mergeRun());
+      const outcome = await pool2.session(c.req.param("sessionId")).execute({ command: "merge_all" }, { kind: "user" });
+      if (outcome.payload?.kind === "merge") return c.json(outcome.payload.result);
+      if (!outcome.ok) throw new core.TaskControlError(outcome.message);
+      throw new Error("Merge all answered without its result.");
     } catch (err) {
       return failure(c, err, "task edit");
     }
@@ -1206,22 +1183,9 @@ function plansRoute(pool2) {
   });
   router.put("/:sessionId/tasks/:taskId", async (c) => {
     try {
-      const { assignedRunner, dependencies, ...rest } = await c.req.json();
-      if (rest.assignedModel === null) rest.assignedModel = void 0;
-      const session = pool2.session(c.req.param("sessionId"));
-      const taskId = c.req.param("taskId");
-      const hasRunner = typeof assignedRunner === "string";
-      const hasDeps = Array.isArray(dependencies);
-      let result = null;
-      if (hasRunner) result = await session.setTaskRunner(taskId, assignedRunner);
-      if (hasDeps) {
-        try {
-          result = await session.setTaskDependencies(taskId, dependencies.map(String));
-        } catch (err) {
-          return failure(c, err, "task dependencies", { fallback: 400 });
-        }
-      }
-      if (Object.keys(rest).length > 0 || !hasRunner && !hasDeps) result = await session.updateTask(taskId, rest);
+      const changes = await c.req.json();
+      if (changes.assignedModel === null) changes.assignedModel = void 0;
+      const result = await pool2.session(c.req.param("sessionId")).updateTask(c.req.param("taskId"), changes);
       if (!result) return refuse(c, 404, "Task not found", "task_not_found");
       return c.json({ ok: true });
     } catch (err) {
@@ -1249,8 +1213,11 @@ function plansRoute(pool2) {
   });
   router.post("/:sessionId/review/approve", async (c) => {
     try {
-      const plan = await pool2.session(c.req.param("sessionId")).approveReview();
-      return c.json({ plan: core.surfacePlan(plan) });
+      const session = pool2.session(c.req.param("sessionId"));
+      const plan = session.planState;
+      if (!plan) throw new core.NoPlanError("review");
+      const { message } = await runUserCommand(session, { command: "approve_review" });
+      return c.json({ plan: core.surfacePlan(plan), message });
     } catch (err) {
       return failure(c, err, "review approve");
     }
@@ -1415,9 +1382,9 @@ function approvalsRoute(pool2) {
     const answer = answerOf(await c.req.json().catch(() => null));
     const decided = core.toApprovalDecision(answer);
     const request = pool2.outstandingApprovals(sessionId).find((pending) => pending.id === approvalId)?.request;
-    if (decided.decision === "deny" && request?.taskId) {
+    if (request?.taskId) {
       const outcome = await pool2.session(sessionId).execute(
-        { command: "answer_approval", task: request.taskId, approval: approvalId, answer: "deny", ...decided.note ? { note: decided.note } : {} },
+        { command: "answer_approval", task: request.taskId, approval: approvalId, answer: decided.decision, ...decided.decision === "deny" && decided.note ? { note: decided.note } : {} },
         { kind: "user" }
       );
       if (!outcome.ok) return refuse(c, 400, outcome.message, "refused");