@saadnvd1/agent-os 0.3.631 → 0.3.639

package/lib/tasks/move-flow.ts

@@ -16,19 +16,15 @@ import { holderRefusal } from "./held";
 import { isPaused } from "../orchestrator/pause";
 import { sessionWorkspace } from "../models/resolve";
 import { arrived as arrivedHere, importTask } from "./import";
-import {
-  forgetHostTasks,
-  requireCapability,
-  postIdempotent,
-  unknownOutcome,
-} from "./remote";
-import { arrivedThere, settleMovedOut, tell } from "./move-recover";
+import * as client from "./contract/client";
+import { arrivedThere, settleMovedOut } from "./move-recover";
 import {
   finishProgress,
   moveSteps,
   startProgress,
   stepProgress,
 } from "./move-progress";
+import { setTask } from "../db/session-parts";
 
 const LIVE = new Set(["running", "moving"]);
 
@@ -89,7 +85,7 @@ export async function moveTask(id: string, toHostId: string): Promise<Session> {
 }
 
 const requireChatMoves = (link: HostLink) =>
-  requireCapability(link, "chat-move", "chat tasks");
+  client.requireCapability(link, "chat-move", "chat tasks");
 
 const unconfirmed = (where: string, err: unknown) =>
   new Error(
@@ -101,7 +97,11 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   const chat = session.view === "chat";
   if (chat) await requireChatMoves(link);
   if (isOrchestrated(session))
-    await requireCapability(link, "orchestrated-move", "orchestrator tasks");
+    await client.requireCapability(
+      link,
+      "orchestrated-move",
+      "orchestrator tasks"
+    );
   startProgress(
     session.id,
     link.hostName,
@@ -118,15 +118,10 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   stepProgress(session.id, "arrive");
   let there: Session;
   try {
-    ({ session: there } = await postIdempotent<{ session: Session }>(
-      link,
-      "/api/tasks/import",
-      bundle,
-      600000
-    ));
+    ({ session: there } = await client.importBundle(link, bundle));
   } catch (err) {
     // It may be running there already: resuming here could run it twice.
-    if (unknownOutcome(err)) throw unconfirmed(link.hostName, err);
+    if (client.unknownOutcome(err)) throw unconfirmed(link.hostName, err);
     await resumeTask(session.id);
     throw err;
   }
@@ -134,45 +129,43 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
 }
 
 function mirrorRunning(id: string): void {
-  db.prepare(
-    `UPDATE sessions SET task_status = 'running', moved_to = NULL
-       WHERE id = ? AND task_status = 'moving'`
-  ).run(id);
+  setTask(
+    db,
+    id,
+    { task_status: "running", moved_to: null },
+    { task_status: "moving" }
+  );
 }
 
 async function moveIn(mirror: Session): Promise<Session> {
   const link = requireHostLink(mirror.host_id);
   if (mirror.view === "chat") await requireChatMoves(link);
   startProgress(mirror.id, "this machine", moveSteps("in", link.hostName));
-  const path = `/api/tasks/${encodeURIComponent(mirror.id)}`;
   // A retry after it arrived here but that machine didn't hear: tidy up.
   let here = arrivedHere(mirror.id);
   if (!here) {
     // Moving, so nothing reads the mirror as a task to judge, or sign off,
     // while it leaves (a refusal below puts it back).
-    db.prepare(
-      `UPDATE sessions SET task_status = 'moving', moved_to = 'this machine'
-         WHERE id = ? AND task_status = 'running'`
-    ).run(mirror.id);
+    setTask(
+      db,
+      mirror.id,
+      { task_status: "moving", moved_to: "this machine" },
+      { task_status: "running" }
+    );
     // That machine resumes the agent itself if its half fails there.
     stepProgress(mirror.id, "export");
     let bundle: TaskBundle;
     try {
-      ({ bundle } = await postIdempotent<{ bundle: TaskBundle }>(
-        link,
-        `${path}/export`,
-        { to: os.hostname() },
-        300000
-      ));
+      bundle = await client.exportOut(link, mirror.id, os.hostname());
     } catch (err) {
       mirrorRunning(mirror.id);
-      if (unknownOutcome(err)) throw unconfirmed(link.hostName, err);
+      if (client.unknownOutcome(err)) throw unconfirmed(link.hostName, err);
       throw err;
     }
     try {
       here = await importTask(bundle);
     } catch (err) {
-      await tell(link, `${path}/resume`, { force: true }).catch((e) => {
+      await client.resume(link, mirror.id, { force: true }).catch((e) => {
         throw new Error(
           `${(err as Error).message}; and ${link.hostName} didn't resume it: ${e.message}`
         );
@@ -186,7 +179,7 @@ async function moveIn(mirror: Session): Promise<Session> {
   // "moving" there, which nothing can sign off), the mirror stays, so Move
   // here again comes back to this.
   try {
-    await tell(link, `${path}/moved`, { to: os.hostname() });
+    await client.confirmMoved(link, mirror.id, os.hostname());
   } catch (err) {
     throw new Error(
       `It's running here now, but ${link.hostName} didn't confirm (${(err as Error).message}). Press Move here again to tidy up.`
@@ -197,8 +190,8 @@ async function moveIn(mirror: Session): Promise<Session> {
     mirror.id,
     mirror.host_id
   );
-  forgetHostTasks(link.hostId);
+  client.forget(link.hostId);
   return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(here.id) as Session;
 }

package/lib/tasks/move-guard.ts

@@ -29,7 +29,15 @@ export function moveRefusal(session: Session): string | null {
     return "Its repo is encrypted with git-crypt and the key never leaves this machine, so it stays here";
   if (escalations(session.id).length)
     return "It's waiting on you (an escalated gate), so it stays here";
-  if (session.plan_only && session.plan_phase !== "implementing")
+  if (
+    session.plan_only &&
+    session.plan_phase !== "implementing" &&
+    // A plan another machine placed here moves to it once written.
+    !(
+      session.plan_waits_for_caller &&
+      (session.plan_phase === "awaiting" || session.plan_phase === "handoff")
+    )
+  )
     return "It's a plan-only task that hasn't been approved, so it stays here";
   const ask = db
     .prepare(
@@ -41,7 +49,7 @@ export function moveRefusal(session: Session): string | null {
     .prepare(
       `SELECT lh_card_id,
          EXISTS (SELECT 1 FROM stack_items WHERE session_id = s.id) AS stacked
-       FROM sessions s WHERE id = ?`
+       FROM session_rows s WHERE id = ?`
     )
     .get(session.id) as
     | { lh_card_id: string | null; stacked: number }

package/lib/tasks/move-recover.ts

@@ -8,38 +8,19 @@
 
 import { db, type Session } from "../db";
 import { hostIdNamed } from "../hosts";
-import { hostApi, hostLink, type HostLink } from "../hosts/remote-api";
+import { hostLink, type HostLink } from "../hosts/remote-api";
 import { getTaskSession } from "./session";
 import { markMoved, resumeTask } from "./move";
-import { forgetHostTasks, mirrorTask, unknownOutcome } from "./remote";
+import * as client from "./contract/client";
+import { mirrorTask } from "./contract/start";
 import { carryTaskState } from "./move-carry";
 
-/** POST, repeated when the outcome is unknown (the calls are idempotent). */
-export async function tell(
-  link: HostLink,
-  path: string,
-  body: object = {}
-): Promise<void> {
-  for (let i = 0; ; i++) {
-    try {
-      await hostApi(link, path, { body });
-      return;
-    } catch (err) {
-      if (!unknownOutcome(err) || i === 2) throw err;
-    }
-  }
-}
-
 /** The task a move from this session made there, or null. Throws if unsure. */
 export async function arrivedThere(
   link: HostLink,
   sessionId: string
 ): Promise<Session | null> {
-  const { session } = await hostApi<{ session: Session | null }>(
-    link,
-    `/api/tasks/arrived?from=${encodeURIComponent(sessionId)}`
-  );
-  return session;
+  return client.arrived(link, sessionId);
 }
 
 export function settleMovedOut(
@@ -53,9 +34,9 @@ export function settleMovedOut(
     mirrorTask(hostId, session.project_id, there);
     carryTaskState(session.id, there.id);
   })();
-  forgetHostTasks(hostId);
+  client.forget(hostId);
   return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(there.id) as Session;
 }
 

package/lib/tasks/move.ts

@@ -36,6 +36,7 @@ import {
   latestSessionId,
   readTranscript,
 } from "./transcript";
+import { setTask } from "../db/session-parts";
 
 export * from "./move-bundle";
 
@@ -88,13 +89,13 @@ async function pushOwnBranch(cwd: string, branch: string): Promise<void> {
  * arrived, and then it would run on both.
  */
 function claimMoving(id: string, to: string): { fresh: boolean } {
-  const fresh = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'moving', moved_to = ?
-         WHERE id = ? AND task_status = 'running'`
-    )
-    .run(to, id);
-  if (fresh.changes === 1) return { fresh: true };
+  const fresh = setTask(
+    db,
+    id,
+    { task_status: "moving", moved_to: to },
+    { task_status: "running" }
+  );
+  if (fresh) return { fresh: true };
   const { task_status, moved_to } = getTaskSession(id);
   if (task_status === "moving" && moved_to === to) return { fresh: false };
   throw new Error(
@@ -140,10 +141,7 @@ function orchestratedBundle(session: Session): OrchestratedBundle {
     modelProvider: session.model_provider ?? null,
     modelOverrides: session.model_overrides ?? null,
     // moveRefusal keeps an unapproved plan-only task here.
-    planPhase: (session.plan_phase ?? null) as
-      | "planning"
-      | "implementing"
-      | null,
+    planPhase: (session.plan_phase ?? null) as OrchestratedBundle["planPhase"],
     planFile: readPlanFile(session.working_directory),
     orchestrator: orchestratorOf(session),
   };
@@ -215,6 +213,10 @@ export async function exportTask(id: string, to: string): Promise<TaskBundle> {
           : null,
       chat: chatBundle,
       orchestrated: isOrchestrated(now) ? orchestratedBundle(now) : undefined,
+      planWait:
+        now.plan_waits_for_caller && now.plan_phase === "awaiting"
+          ? { file: readPlanFile(cwd) }
+          : undefined,
     };
   } finally {
     packed();
@@ -249,12 +251,12 @@ export async function exportOrResume(
 }
 
 export function markMoved(id: string, to: string): void {
-  const moved = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'moved', moved_to = ?
-       WHERE id = ? AND task_status IN ('running', 'moving')`
-    )
-    .run(to, id).changes;
+  const moved = setTask(
+    db,
+    id,
+    { task_status: "moved", moved_to: to },
+    { task_status: ["running", "moving"] }
+  );
   // It goes on there with a copy of its own.
   if (moved) void dropSessionDatabase(id);
 }
@@ -268,25 +270,24 @@ export function markMoved(id: string, to: string): void {
  */
 export async function resumeTask(id: string, note?: string): Promise<void> {
   if (exporting.has(id)) throw new Error("It's moving right now");
-  const claimed = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'running' WHERE id = ? AND task_status = 'moving'`
-    )
-    .run(id);
+  const claimed = setTask(
+    db,
+    id,
+    { task_status: "running" },
+    { task_status: "moving" }
+  );
   const session = getTaskSession(id);
-  if (claimed.changes !== 1) {
+  if (!claimed) {
     if (session.task_status === "running") return;
     throw new Error(`Task is already ${session.task_status}`);
   }
   try {
     await relaunch(session, note);
   } catch (err) {
-    db.prepare(
-      `UPDATE sessions SET task_status = 'moving' WHERE id = ? AND task_status = 'running'`
-    ).run(id);
+    setTask(db, id, { task_status: "moving" }, { task_status: "running" });
     throw err;
   }
-  db.prepare(`UPDATE sessions SET moved_to = NULL WHERE id = ?`).run(id);
+  setTask(db, id, { moved_to: null });
 }
 
 async function relaunch(session: Session, note?: string): Promise<void> {

package/lib/tasks/moved-away.ts

@@ -12,7 +12,7 @@ import { settleWorktree, type WorktreeFate } from "../done/worktree";
 import { archiveSession } from "../done/archive";
 
 export async function cleanUpMovedAway(id: string): Promise<WorktreeFate> {
-  const s = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  const s = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
   if (!s || s.task_status !== "moved" || !s.held_by_device)

package/lib/tasks/pause-hold.ts

@@ -2,6 +2,7 @@
 // can hold a message for it without loading the pause machinery.
 
 import { db, type TaskPause } from "../db";
+import { setPause } from "../db/session-parts";
 
 export interface PauseHold {
   pauseId: number;
@@ -11,7 +12,7 @@ export interface PauseHold {
 export function pauseHoldOf(sessionId: string): PauseHold | null {
   const row = db
     .prepare(
-      `SELECT pause_id, paused_until FROM sessions
+      `SELECT pause_id, paused_until FROM session_rows
        WHERE id = ? AND pause_state IN ('pausing', 'paused') AND pause_id IS NOT NULL`
     )
     .get(sessionId) as
@@ -45,10 +46,17 @@ export function endPause(
       `UPDATE task_pauses SET state = 'ended', ended_at = datetime('now'), end_reason = ?
        WHERE id = ? AND state != 'ended'`
     ).run(reason, row.id);
-    db.prepare(
-      `UPDATE sessions SET pause_state = NULL, paused_until = NULL, pause_id = NULL, pause_note = NULL
-       WHERE id = ? AND pause_id = ?`
-    ).run(row.session_id, row.id);
+    setPause(
+      db,
+      row.session_id,
+      {
+        pause_state: null,
+        paused_until: null,
+        pause_id: null,
+        pause_note: null,
+      },
+      { pause_id: row.id }
+    );
   })();
 }
 

package/lib/tasks/pause.ts

@@ -34,9 +34,7 @@ import { openBySubject, workSubject } from "../orchestrator/asks";
 import { queueEventOnce } from "../orchestrator/events";
 import { isPaused } from "../orchestrator/pause";
 import { isMerging } from "./finish";
-import { autoHold } from "./auto-hold";
-import { localView } from "../load/machines";
-import { machineHold } from "./schedule";
+import { loadHoldFor, resumeHoldFor } from "./hold-checks";
 import {
   continuePrompt,
   durationText,
@@ -52,6 +50,7 @@ import {
   type PauseView,
   type Priority,
 } from "./schedule-types";
+import { setPause } from "../db/session-parts";
 
 export class PauseRefused extends Error {}
 
@@ -74,7 +73,7 @@ const nudge = () =>
   void import("./queue").then((q) => q.tickQueueSoon()).catch(() => undefined);
 
 const sessionOf = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 
@@ -167,10 +166,9 @@ export function requestPause(sessionId: string, req: PauseRequest): TaskPause {
       until ? toSqliteTime(until) : null,
       existing.id
     );
-    db.prepare(`UPDATE sessions SET paused_until = ? WHERE id = ?`).run(
-      until ? toSqliteTime(until) : null,
-      sessionId
-    );
+    setPause(db, sessionId, {
+      paused_until: until ? toSqliteTime(until) : null,
+    });
     // "Pause now" takes over: the first driver is superseded, not raced.
     drive(sessionId, existing.id, mode === "now");
     return pauseRow(existing.id)!;
@@ -192,9 +190,11 @@ export function requestPause(sessionId: string, req: PauseRequest): TaskPause {
         until ? toSqliteTime(until) : null
       ).lastInsertRowid
   );
-  db.prepare(
-    `UPDATE sessions SET pause_state = 'pausing', paused_until = ?, pause_id = ? WHERE id = ?`
-  ).run(until ? toSqliteTime(until) : null, id, sessionId);
+  setPause(db, sessionId, {
+    pause_state: "pausing",
+    paused_until: until ? toSqliteTime(until) : null,
+    pause_id: id,
+  });
   drive(sessionId, id);
   return pauseRow(id)!;
 }
@@ -309,10 +309,7 @@ function markPaused(sessionId: string, pauseId: number): void {
          WHERE id = ? AND state = 'pausing'`
       )
       .run(pauseId).changes;
-    if (n)
-      db.prepare(`UPDATE sessions SET pause_state = 'paused' WHERE id = ?`).run(
-        sessionId
-      );
+    if (n) setPause(db, sessionId, { pause_state: "paused" });
     return n;
   })();
   if (!changed) return;
@@ -361,10 +358,7 @@ export function setResumeTime(sessionId: string, until: Date | null): void {
     db.prepare(
       `UPDATE task_pauses SET until_at = ?, resume_requested_at = NULL WHERE id = ? AND state IN ('pausing','paused')`
     ).run(value, row.id);
-    db.prepare(`UPDATE sessions SET paused_until = ? WHERE id = ?`).run(
-      value,
-      sessionId
-    );
+    setPause(db, sessionId, { paused_until: value });
   })();
 }
 
@@ -395,39 +389,14 @@ export function requestResume(sessionId: string, actor: PauseBy): void {
     );
 }
 
-// Why this machine's load rules out starting an agent now, or null. Only a
-// red (or still settling) machine holds a resume; amber doesn't.
-export function loadHoldFor(s: Session): string | null {
-  const project = s.project_id ? getProject(s.project_id) : null;
-  if (!project || isRemoteHost(s.host_id ?? project.host_id)) return null;
-  const hold = machineHold(
-    {
-      heavy: false,
-      needsUnmet: false,
-      remote: false,
-      priority: DEFAULT_PRIORITY,
-    },
-    localView(),
-    Date.now()
-  );
-  return hold?.code === "load_red" ? hold.text.replace(/^Waiting: /, "") : null;
-}
-
-// Why a resume this actor asked for must wait: this machine's load, and for
-// the orchestrator also what holds its own starts (it is paused, or the
-// usage window). Saad's own resume skips the second.
-export function resumeHoldFor(s: Session, actor: PauseBy): string | null {
-  const load = loadHoldFor(s);
-  if (load) return load;
-  if (actor !== "orchestrator") return null;
-  const ws = s.project_id ? getProject(s.project_id)?.workspace_id : null;
-  return autoHold(ws ?? null)?.text.replace(/^Waiting: /, "") ?? null;
-}
+export { loadHoldFor, resumeHoldFor };
 
 export function setPauseNote(sessionId: string, note: string | null): void {
-  db.prepare(
-    `UPDATE sessions SET pause_note = ? WHERE id = ? AND pause_state = 'paused' AND COALESCE(pause_note, '') != COALESCE(?, '')`
-  ).run(note, sessionId, note);
+  const row = db
+    .prepare(`SELECT pause_note FROM session_rows WHERE id = ?`)
+    .get(sessionId) as { pause_note: string | null } | undefined;
+  if ((row?.pause_note ?? "") === (note ?? "")) return;
+  setPause(db, sessionId, { pause_note: note }, { pause_state: "paused" });
 }
 
 export type ResumeOutcome =
@@ -482,7 +451,7 @@ export function dueResumes(): DueResume[] {
     .prepare(
       `SELECT p.id AS pause_id, p.session_id, p.by_kind, p.until_at, p.resume_requested_at, p.resume_by_kind,
               s.project_id, s.priority
-       FROM task_pauses p JOIN sessions s ON s.id = p.session_id
+       FROM task_pauses p JOIN session_rows s ON s.id = p.session_id
        WHERE p.state = 'paused' AND p.resume_requested_at IS NOT NULL
          AND s.task_status IN ('running') AND s.archived_at IS NULL`
     )
@@ -612,9 +581,7 @@ export async function claimResume(
         }),
         Date.now()
       );
-    db.prepare(
-      `UPDATE sessions SET pause_state = 'resuming', pause_note = NULL WHERE id = ?`
-    ).run(sessionId);
+    setPause(db, sessionId, { pause_state: "resuming", pause_note: null });
     return true;
   })();
   if (!claimed) return "gone";

package/lib/tasks/placement.ts

@@ -12,12 +12,8 @@ import path from "path";
 import { db } from "../db";
 import { loadProjectConfig } from "../project-config";
 import { MACHINE_NEEDS } from "../project-config/schema";
-import {
-  machineHold,
-  type Candidate,
-  type Hold,
-  type MachineView,
-} from "./schedule";
+import { machineHold, placeable, type MachineView } from "./holds";
+import type { Candidate } from "./schedule";
 
 export type Need = (typeof MACHINE_NEEDS)[number];
 export type NeedsSource = "task" | "brief" | "config" | "inferred" | "none";
@@ -138,8 +134,6 @@ export function unplaceable(r: {
   host_id: string | null;
 }): string | null {
   if (r.host_id) return "it was pinned to a machine";
-  if (r.plan_only) return "plan-only tasks run on this machine";
-  if (r.plan) return "plan-first tasks run on this machine";
   if (r.agent_type && r.agent_type !== "claude")
     return "only Claude tasks run on another machine";
   if (r.model_overrides) return "per-role models run on this machine";
@@ -153,11 +147,24 @@ export interface PeerOption {
   capabilities: string[];
   // It can hold an orchestrator's task (false: an older AgentOS). Unset: yes.
   holds?: boolean;
+  // It can run a plan step that stops for this machine (false: an older
+  // AgentOS). Unset: yes.
+  plans?: boolean;
   // The project exists there (projectMachines said null).
   hasProject: boolean;
   loadPerCore: number;
 }
 
+// A start that plans first: the plan phase only reads code, so it needs no
+// simulator or Mac, and the plan-only skip of load holds doesn't apply to
+// where it goes, only to whether it may wait. The candidate as a plan phase
+// sees it.
+export const asPlanPhase = <
+  T extends Pick<Candidate, "heavy" | "needsUnmet" | "planOnly">,
+>(
+  c: T
+): T => ({ ...c, heavy: false, needsUnmet: false, planOnly: false });
+
 export interface Placement {
   hostId: string;
   name: string;
@@ -165,13 +172,6 @@ export interface Placement {
   why: string;
 }
 
-const LOAD_HOLDS = new Set<Hold["code"]>([
-  "load_red",
-  "load_amber",
-  "needs",
-  "heavy",
-]);
-
 // True when the home machine's load or needs rule this start out, which is
 // the only time a linked machine is worth asking.
 export const wantsPlacing = (
@@ -181,7 +181,7 @@ export const wantsPlacing = (
 ): boolean => {
   if (c.remote || home.reading) return false;
   const hold = machineHold(c, home, now);
-  return !!hold && LOAD_HOLDS.has(hold.code);
+  return !!hold && placeable(hold);
 };
 
 // Null: start it at home (or hold it there for a reason placing doesn't

package/lib/tasks/plan-view.ts

@@ -17,6 +17,8 @@ import {
   type TaskPlan,
 } from "./loop-types";
 import { expandHome } from "./session";
+import { isRemoteHost } from "../hosts";
+import { remotePlanPath } from "./contract/plan-path";
 
 const TITLE_MAX = 120;
 
@@ -131,7 +133,10 @@ export function taskPlan(session: Session): TaskPlan | null {
     };
 
   if (phase && session.worktree_path) {
-    const file = path.join(expandHome(session.worktree_path), PLAN_FILE);
+    // A plan written on a linked machine is read from the copy kept here.
+    const file = isRemoteHost(session.host_id)
+      ? remotePlanPath(session.id)
+      : path.join(expandHome(session.worktree_path), PLAN_FILE);
     const text = readHead(file, PLAN_TEXT_MAX);
     if (text !== null || phase === "planning") {
       const body = text ?? "";
@@ -141,13 +146,16 @@ export function taskPlan(session: Session): TaskPlan | null {
         status:
           phase === "planning"
             ? "writing"
-            : phase === "awaiting"
+            : phase === "awaiting" || phase === "handoff"
               ? "ready"
               : "approved",
         source: "step",
         title: planTitle(body),
         path: text !== null ? PLAN_FILE : null,
-        pieces: phase === "awaiting" ? piecesView(session, file) : null,
+        pieces:
+          phase === "awaiting" || phase === "handoff"
+            ? piecesView(session, file)
+            : null,
         ...capped(body),
       };
     }