@monster-orange/den 0.4.21 → 0.4.23

package/src/ui/cli/agents-command.ts

@@ -70,6 +70,10 @@ import { HostError } from "../../shared/sessions/client.js";
 import { checkHandback } from "../../shared/agents/handback.js";
 import { checkHandoff } from "../../shared/agents/handoff.js";
 import { handoffFile, reasonText } from "../../shared/agents/rotation.js";
+import {
+  parseRotateValue,
+  type OverrideScope,
+} from "../../shared/agents/rotate-settings.js";
 import {
   agentFilesDir,
   listRecords,
@@ -85,10 +89,15 @@ import {
   listRuntimes,
   loadAgentWorkspaces,
   relaunchAgent,
+  resumeOrRelaunch,
+  keepAgentConversation,
+  askForHandoff,
+  rotationSettings,
+  setRotationSetting,
   removeAgent,
   removeStopped,
+  renameAgent,
   resolveAgentsDeps,
-  resumeAgent,
   resumeInterrupted,
   startAgent,
   stopAgent,
@@ -99,6 +108,7 @@ import {
   type RuntimeChoice,
   type Started,
 } from "./agent-ops.js";
+import { peerSessionName } from "../../shared/agents/session-name.js";
 import {
   columns,
   guarded,
@@ -119,7 +129,7 @@ export {
 
 export const AGENTS_HELP = {
   usage:
-    "agents <list|start|stop|resume|relaunch|import|persona|rm|personas|doctor|handback-check|handoff-check> ...",
+    "agents <list|start|stop|resume|relaunch|rotate|keep|handoff|import|persona|rename|rm|personas|doctor|handback-check|handoff-check> ...",
   lines: [
     "Agents: a persona and a workspace, run by a runtime in a session that",
     "outlives the web server (see `{cli} sessions`).",
@@ -144,6 +154,19 @@ export const AGENTS_HELP = {
     "    compactions (default 3) or its pull request merged, and its handoff.md",
     "    passes the check, a fresh conversation (same persona, workspace, folder,",
     "    grants) whose first prompt is the handoff",
+    "{cli} agents rotate [--agent|--persona|--workspace|--service <x>] [-w <ws>] <key> <value>",
+    "{cli} agents rotate [scope] --unset <key>   ·   {cli} agents rotate   ·   {cli} agents rotate <id> --show",
+    "    rotation settings: after_compactions <n>|never (default 3), on_due",
+    "    auto|ask|off (default auto: Den asks for the handoff at idle and",
+    "    relaunches by itself), on_pr_merged true|false. No scope: this install.",
+    "    --persona <p> -w <ws>: the persona in that workspace. The most specific",
+    "    wins: agent, persona in a workspace, persona, workspace, service,",
+    "    install, org config. --show: an agent's values and where each comes from",
+    "{cli} agents keep <id> [-w <ws>] [--never]",
+    "    keep its conversation: the compaction count starts again; --never: this",
+    "    agent never rotates. A person's only",
+    "{cli} agents handoff <id> [-w <ws>]",
+    "    ask a running agent, at idle, to write its handoff",
     "{cli} agents import -w <ws> [--runtime <r>] [--json]",
     "{cli} agents import -w <ws> --session <id> --persona <p> [--runtime <r>] [--id <id>] [--model <m>]",
     "    bring in a conversation started outside Den: the first lists the runtime's",
@@ -156,6 +179,11 @@ export const AGENTS_HELP = {
     "    persona's role, permissions and commands; id, name, folder and model stay.",
     "    Mid-turn it asks: --after-turn waits for the turn to end, --now stops it.",
     "    A person's only (refused in an agent's session)",
+    "{cli} agents rename <id> <name> [-w <ws>]",
+    "{cli} agents rename <id> --clear [-w <ws>]",
+    "    name an agent (its tab, row and pane header); the id never changes.",
+    "    Other sessions see it as {cli}-<ws>:<name> from its next start or resume.",
+    "    --clear: back to its id",
     "{cli} agents rm <id> [-w <ws>]",
     "{cli} agents rm --stopped [-w <ws>]",
     "    forget a stopped, interrupted or exited agent (never a running one);",
@@ -470,7 +498,15 @@ async function stop(args: string[], d: AgentsResolved): Promise<number> {
 async function resume(args: string[], d: AgentsResolved): Promise<number> {
   if (args.includes("--all-interrupted")) return resumeAll(args, d);
   const { id, ws } = idAndWorkspace("agents resume", args);
-  const s = await resumeAgent(d, id, ws);
+  // D28: a due agent under auto relaunches from its handoff instead.
+  const r = await resumeOrRelaunch(d, id, ws);
+  if (r.kind === "relaunched")
+    return report(
+      d,
+      r.s,
+      `relaunched agent ${r.s.rec.id} from its handoff (the last session ended after ${r.s.why}) as ${r.s.rec.sessionName} in ${r.s.rec.cwd}`,
+    );
+  const s = r.s;
   if (s.fresh) d.out(`agent ${s.rec.id}: ${FRESH_NOTE}`);
   return report(
     d,
@@ -480,6 +516,135 @@ async function resume(args: string[], d: AgentsResolved): Promise<number> {
 }
 
 /** `agents relaunch <id> [-w <ws>]` (den#4). */
+/** D28: refused in an agent's session (an agent could stop its own rotation). */
+function personOnly(where: string, d: AgentsResolved): void {
+  if (d.env[ACTOR_TOKEN_ENV] !== undefined)
+    throw new AgentError(
+      `${where}: only a person can change rotation (this is an agent's session)`,
+    );
+}
+
+const ROTATE_SCOPE_FLAGS: Record<string, OverrideScope> = {
+  "--agent": "agent",
+  "--persona": "persona",
+  "--workspace": "workspace",
+  "--service": "service",
+};
+
+/**
+ * `agents rotate` (D28): with no arguments, the settings and overrides;
+ * `[--agent|--persona|--workspace|--service <x>] [-w <ws>] <key> <value>`
+ * sets one (no scope flag: this install's), `--unset` clears it. `--persona
+ * <p> -w <ws>`: the persona in that workspace. `agents rotate <id> --show`:
+ * that agent's effective values and where each comes from.
+ */
+async function rotate(args: string[], d: AgentsResolved): Promise<number> {
+  const where = "agents rotate";
+  if (args.includes("--show")) {
+    const { id, ws } = idAndWorkspace(
+      where,
+      args.filter((a) => a !== "--show"),
+    );
+    const r = rotationSettings(d, id, ws);
+    if (!r.effective) {
+      d.err(`✗ ${where}: ${id}'s persona or the config can't be read`);
+      return 1;
+    }
+    const e = r.effective;
+    d.out(`agent ${e.agent}:`);
+    d.out(
+      `  after_compactions  ${e.afterCompactions === 0 ? "never" : e.afterCompactions}  (from ${e.from?.after_compactions})`,
+    );
+    d.out(`  on_due             ${e.onDue}  (from ${e.from?.on_due})`);
+    d.out(
+      `  on_pr_merged       ${e.onPrMerged}  (from ${e.from?.on_pr_merged})`,
+    );
+    return 0;
+  }
+  if (!args.length) {
+    const r = rotationSettings(d);
+    const vals = (v: object) =>
+      Object.entries(v)
+        .map(([k, x]) => `${k}=${String(x)}`)
+        .join(" ") || "(none)";
+    d.out(`default: ${vals(r.defaults)}`);
+    d.out(`org config: ${vals(r.org)}`);
+    d.out(`this install: ${vals(r.install)}`);
+    for (const [scope, byTarget] of Object.entries(r.overrides))
+      for (const [target, v] of Object.entries(byTarget ?? {}))
+        d.out(`${scope} ${target}: ${vals(v)}`);
+    return 0;
+  }
+  personOnly(where, d);
+  const unset = args.includes("--unset");
+  const rest = args.filter((a) => a !== "--unset");
+  let scope: OverrideScope | "install" = "install";
+  let target: string | undefined;
+  let ws: string | undefined;
+  const pos: string[] = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "-w" || a === "--ws") {
+      ws = rest[++i];
+      if (!ws) throw new UsageError(`${where}: ${a} needs a workspace`);
+    } else if (a in ROTATE_SCOPE_FLAGS) {
+      if (scope !== "install")
+        throw new UsageError(`${where}: one scope at a time`);
+      scope = ROTATE_SCOPE_FLAGS[a];
+      target = rest[++i];
+      if (!target) throw new UsageError(`${where}: ${a} needs a name`);
+    } else if (a.startsWith("--"))
+      throw new UsageError(`${where}: unknown flag ${a}`);
+    else pos.push(a);
+  }
+  if (ws) {
+    if (scope !== "persona")
+      throw new UsageError(
+        `${where}: -w goes with --persona (the persona in that workspace); use --workspace <ws> for a workspace`,
+      );
+    scope = "persona-workspace";
+    target = `${target}@${ws}`;
+  }
+  const [key, raw] = pos;
+  if (!key || (unset ? pos.length !== 1 : pos.length !== 2))
+    throw new UsageError(
+      `${where} [--agent|--persona|--workspace|--service <x>] <key> <value> (or --unset <key>)`,
+    );
+  setRotationSetting(d, {
+    scope,
+    ...(target !== undefined ? { target } : {}),
+    key,
+    value: unset ? null : parseRotateValue(key, raw!),
+  });
+  const at = scope === "install" ? "this install" : `${scope} ${target}`;
+  d.out(unset ? `${key} cleared at ${at}` : `${key} = ${raw} at ${at}`);
+  return 0;
+}
+
+/** `agents keep <id> [-w <ws>] [--never]` (D28 Keep this conversation). */
+function keep(args: string[], d: AgentsResolved): number {
+  const where = "agents keep";
+  personOnly(where, d);
+  const never = args.includes("--never");
+  const { id, ws } = idAndWorkspace(
+    where,
+    args.filter((a) => a !== "--never"),
+  );
+  const rec = keepAgentConversation(d, id, ws, { never });
+  d.out(
+    `kept ${rec.id}'s conversation: its compaction count starts again${never ? "; it never rotates (agents rotate --agent " + rec.id + " --unset after_compactions to undo)" : ""}`,
+  );
+  return 0;
+}
+
+/** `agents handoff <id> [-w <ws>]` (D28 Write handoff). */
+async function handoff(args: string[], d: AgentsResolved): Promise<number> {
+  const { id, ws } = idAndWorkspace("agents handoff", args);
+  const rec = await askForHandoff(d, id, ws);
+  d.out(`asked ${rec.id} to write its handoff; Den relaunches it from it`);
+  return 0;
+}
+
 async function relaunch(args: string[], d: AgentsResolved): Promise<number> {
   const { id, ws } = idAndWorkspace("agents relaunch", args);
   const s = await relaunchAgent(d, id, ws);
@@ -513,6 +678,28 @@ async function resumeAll(args: string[], d: AgentsResolved): Promise<number> {
 }
 
 /** `agents rm <id> [-w <ws>]`, `agents rm --stopped [-w <ws>]` (AG-14.1b). */
+/** D25: `agents rename <id> <name>|--clear [-w <ws>]`. */
+function rename(args: string[], d: AgentsResolved): number {
+  const where = "agents rename";
+  const p = parseArgs(where, args, { "--workspace": true, "--clear": false });
+  const [id, ...words] = p.positional;
+  if (!id) throw new UsageError(`${where} needs <id> and a name, or --clear`);
+  const name = words.join(" ").trim();
+  if (p.flags["--clear"] && name)
+    throw new UsageError(`${where}: give a name or --clear, not both`);
+  if (!p.flags["--clear"] && !name)
+    throw new UsageError(`${where} needs a name (or --clear)`);
+  const ws =
+    workspaceFlag(where, p) ?? readRecord(d.stateDir(), id)?.workspace ?? "";
+  const rec = renameAgent(d, id, ws, p.flags["--clear"] ? null : name);
+  d.out(
+    rec.displayName
+      ? `renamed agent ${id} to "${rec.displayName}"; others see it as ${peerSessionName(d.cli, rec.workspace, rec)} from its next start or resume`
+      : `agent ${id} has no name now; others see it as ${peerSessionName(d.cli, rec.workspace, rec)} from its next start or resume`,
+  );
+  return 0;
+}
+
 async function rm(args: string[], d: AgentsResolved): Promise<number> {
   const where = "agents rm";
   const p = parseArgs(where, args, { "--workspace": true, "--stopped": false });
@@ -761,12 +948,22 @@ export async function cmdAgents(
         case "relaunch":
           await loadAgentWorkspaces(deps);
           return await relaunch(rest, d);
+        case "rotate":
+          await loadAgentWorkspaces(deps);
+          return await rotate(rest, d);
+        case "keep":
+          return keep(rest, d);
+        case "handoff":
+          await loadAgentWorkspaces(deps);
+          return await handoff(rest, d);
         case "import":
           await loadAgentWorkspaces(deps);
           return await bringIn(rest, d);
         case "persona":
           await loadAgentWorkspaces(deps);
           return await persona(rest, d);
+        case "rename":
+          return rename(rest, d);
         case "rm":
           await loadAgentWorkspaces(deps);
           return await rm(rest, d);

package/src/ui/cli/doctor-command.ts

@@ -67,6 +67,13 @@ import {
 } from "./doctor-onboard.js";
 import { printJson } from "./json-out.js";
 import { ownerCheck, ownerLine } from "./doctor-owner.js";
+import {
+  formatWhere,
+  serviceJobState,
+  whereRows,
+  type WhereDeps,
+  type WhereRow,
+} from "./doctor-where.js";
 
 export interface DoctorRow {
   kind: string;
@@ -387,6 +394,62 @@ export async function doctorJson(
   return { ok: !checks.some((c) => c.status === "fail"), checks };
 }
 
+/** D18/D20: the real probes for doctor's "where it runs" rows. */
+export async function defaultWhereDeps(): Promise<WhereDeps> {
+  const os = await import("os");
+  const { readDenConfig: cfg, readWebServiceConfig } =
+    await import("../../shared/den-config.js");
+  const { readWebPort } = await import("../../shared/edge/config.js");
+  const { getDistRoot } = await import("../../shared/paths.js");
+  const { connectHost } = await import("../../shared/sessions/client.js");
+  const { sessionPaths } = await import("../../shared/sessions/paths.js");
+  return {
+    cli: product().cli,
+    platform: process.platform,
+    server: async () => {
+      const port = readWebPort(getDistRoot());
+      const res = await fetch(`http://localhost:${port}/api/server-info`, {
+        signal: AbortSignal.timeout(1500),
+      });
+      if (!res.ok) return null;
+      const body = (await res.json()) as { launchd?: string | null };
+      return { launchd: body.launchd ?? null };
+    },
+    host: async () => {
+      const c = await connectHost(sessionPaths(getStateDir()).socket);
+      try {
+        return {
+          launchd: c.hostLaunchd,
+          access: await c.access().catch(() => null),
+        };
+      } finally {
+        c.close();
+      }
+    },
+    service: () => {
+      try {
+        const { label } = readWebServiceConfig(
+          cfg(),
+          getDistRoot(),
+          os.homedir(),
+        );
+        return serviceJobState(label, os.homedir(), process.getuid?.() ?? 0);
+      } catch {
+        return null;
+      }
+    },
+  };
+}
+
+/** A "where it runs" row as a `doctor --json` check. */
+export function whereCheck(r: WhereRow): OnboardCheck {
+  return {
+    id: `where:${r.what.replace(" ", "-")}`,
+    status: r.status,
+    detail: `${r.session}${r.detail ? `: ${r.detail}` : ""}`,
+  };
+}
+
 export async function cmdDoctor(args: string[]): Promise<number> {
   const probe = args.includes("--probe");
   const json = args.includes("--json");
@@ -415,6 +478,9 @@ export async function cmdDoctor(args: string[]): Promise<number> {
     const r = await doctorJson(
       defaultOnboardDeps((url) => probeWebServer(url)),
     );
+    r.checks.push(
+      ...(await whereRows(await defaultWhereDeps())).map(whereCheck),
+    );
     printJson(r);
     return r.ok ? 0 : 1;
   }
@@ -427,6 +493,12 @@ export async function cmdDoctor(args: string[]): Promise<number> {
   console.log("");
   console.log(ownerLine(owner));
   const ownerProblem = owner.status === "fail";
+  // D18/D20: where the server and the session host run (logout).
+  for (const l of formatWhere(
+    await whereRows(await defaultWhereDeps()),
+    readBrand().name,
+  ))
+    console.log(l);
   for (const l of pollingLines(eventsFile(), readBrand().name)) console.log(l);
   const cli = product().cli;
   if (!probe) {

package/src/ui/cli/doctor-where.ts

@@ -0,0 +1,203 @@
+/**
+ * D18/D20: doctor's "where it runs" rows (macOS only).
+ *
+ *   server        the web server's launchd session (/api/server-info)
+ *   session host  the session host's (its hello), where every agent runs
+ *   full disk access  whether the host (and so every agent) has it, and
+ *                 the executable to grant it to: Den's node copy, never the
+ *                 shared node
+ *   service       the installed launchd job: always (a LaunchDaemon, kept
+ *                 across logout) or login (a LaunchAgent in the desktop
+ *                 session), and "plist present, job not loaded" with the
+ *                 bootstrap that loads it
+ *
+ * A process in the desktop session (Aqua) stops at logout: a warning with
+ * the fix. None of these fails doctor.
+ */
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import {
+  ALWAYS_UNPROVEN,
+  endsAtLogout,
+  sessionWarning,
+} from "../../shared/launchd-session.js";
+
+export type ServiceMode = "always" | "login";
+
+export interface ServiceJob {
+  /** unknown: launchctl could not be asked. */
+  state: "loaded" | "not-loaded" | "unknown";
+  mode: ServiceMode;
+  plist: string;
+  domain: string;
+}
+
+export interface WhereDeps {
+  cli: string;
+  platform: NodeJS.Platform;
+  /** The web server's launchd session; null when it does not answer. */
+  server: () => Promise<{ launchd?: string | null } | null>;
+  /** The running session host's; null when none runs. */
+  host: () => Promise<{
+    launchd: string | null;
+    access?: { exe: string; fullDiskAccess: boolean | null } | null;
+  } | null>;
+  service: () => ServiceJob | null;
+}
+
+export interface WhereRow {
+  what: "server" | "session host" | "full disk access" | "service";
+  session: string;
+  status: "ok" | "warn";
+  detail?: string;
+}
+
+function sessionRow(
+  what: "server" | "session host",
+  launchd: string | null | undefined,
+  cli: string,
+): WhereRow {
+  const session = launchd || "unknown";
+  return {
+    what,
+    session,
+    status: endsAtLogout(launchd) ? "warn" : "ok",
+    ...(sessionWarning(launchd, cli, what)
+      ? { detail: sessionWarning(launchd, cli, what)! }
+      : {}),
+  };
+}
+
+export async function whereRows(d: WhereDeps): Promise<WhereRow[]> {
+  if (d.platform !== "darwin") return [];
+  const rows: WhereRow[] = [];
+  const server = await d.server().catch(() => null);
+  rows.push(
+    server
+      ? sessionRow("server", server.launchd, d.cli)
+      : {
+          // Not started yet is not a problem (a fresh install).
+          what: "server",
+          session: "not running",
+          status: "ok",
+          detail: `start it: ${d.cli} web up, or ${d.cli} service install`,
+        },
+  );
+  const host = await d.host().catch(() => null);
+  rows.push(
+    host
+      ? sessionRow("session host", host.launchd, d.cli)
+      : {
+          what: "session host",
+          session: "not running",
+          status: "ok",
+          detail: "it starts when the first terminal or agent does",
+        },
+  );
+  const fda = host?.access;
+  if (fda && fda.fullDiskAccess !== null) {
+    const own = /-sessions-host$/.test(fda.exe);
+    rows.push(
+      fda.fullDiskAccess
+        ? {
+            what: "full disk access",
+            session: "granted",
+            status: "ok",
+            detail: `to ${fda.exe}`,
+          }
+        : {
+            what: "full disk access",
+            session: "not granted",
+            status: "warn",
+            detail: own
+              ? `agents can't open protected folders (other volumes, Desktop, Documents): System Settings → Privacy & Security → Full Disk Access → + → ${fda.exe}, then ${d.cli} sessions host --stop (it restarts with the grant)`
+              : `agents can't open protected folders. The host runs the shared node (${fda.exe}): ${d.cli} service install gives it its own copy to grant, so the grant never goes to every node program`,
+          },
+    );
+  }
+  const svc = d.service();
+  if (!svc)
+    rows.push({
+      what: "service",
+      session: "not installed",
+      status: "ok",
+      detail: `${d.cli} service install (login, the default; --mode always is opt-in and ${ALWAYS_UNPROVEN})`,
+    });
+  else if (svc.state === "not-loaded")
+    rows.push({
+      what: "service",
+      session: `${svc.mode} (${svc.domain})`,
+      status: "warn",
+      detail: `plist present, job not loaded: ${svc.domain === "system" ? "sudo " : ""}launchctl bootstrap ${svc.domain} ${svc.plist}`,
+    });
+  else
+    rows.push({
+      what: "service",
+      session: `${svc.mode} (${svc.domain})`,
+      status: "ok",
+      ...(svc.state === "unknown"
+        ? { detail: "launchctl could not be asked whether it is loaded" }
+        : svc.mode === "always"
+          ? { detail: `opt-in: ${ALWAYS_UNPROVEN}` }
+          : {}),
+    });
+  return rows;
+}
+
+export interface JobProbe {
+  exists: (p: string) => boolean;
+  /** `launchctl print <domain>/<label>`'s exit status (127: no launchctl). */
+  print: (target: string) => number | null;
+}
+
+const realProbe: JobProbe = {
+  exists: (p) => fs.existsSync(p),
+  print: (target) =>
+    spawnSync("launchctl", ["print", target], {
+      stdio: "ignore",
+      timeout: 3000,
+    }).status,
+};
+
+/**
+ * The installed service job for `label`: the LaunchDaemon (always) when
+ * its plist exists, else the LaunchAgent (login); null when neither does.
+ */
+export function serviceJobState(
+  label: string,
+  home: string,
+  uid: number,
+  probe: JobProbe = realProbe,
+): ServiceJob | null {
+  const daemon = path.join("/Library/LaunchDaemons", `${label}.plist`);
+  const agent = path.join(home, "Library", "LaunchAgents", `${label}.plist`);
+  const found: [ServiceMode, string, string] | null = probe.exists(daemon)
+    ? ["always", daemon, "system"]
+    : probe.exists(agent)
+      ? ["login", agent, `gui/${uid}`]
+      : null;
+  if (!found) return null;
+  const [mode, plist, domain] = found;
+  const code = probe.print(`${domain}/${label}`);
+  const state =
+    code === 0
+      ? "loaded"
+      : code === null || code === 127
+        ? "unknown"
+        : "not-loaded";
+  return { state, mode, plist, domain };
+}
+
+/** The rows as doctor prints them, under a heading. */
+export function formatWhere(rows: WhereRow[], title: string): string[] {
+  if (!rows.length) return [];
+  const lines = ["", `${title} doctor: where it runs`, ""];
+  const w = Math.max(...rows.map((r) => r.session.length));
+  for (const r of rows) {
+    const mark = r.status === "ok" ? "✓" : "⚠";
+    lines.push(`  ${r.what.padEnd(16)}  ${r.session.padEnd(w)}  ${mark}`);
+    if (r.detail) lines.push(`    ${r.status === "ok" ? "" : "⚠ "}${r.detail}`);
+  }
+  return lines;
+}

package/src/ui/cli/index.ts

@@ -5317,7 +5317,7 @@ class DenCLI {
       "  mcp --call <tool>    Call one MCP tool and print its result (--list: tool names)",
     );
     console.log(
-      "  service install      Run the web UI as a launchd service (status, print, uninstall)",
+      "  service install      Run the web UI as a launchd service (status, print, uninstall, help)",
     );
     console.log(
       "  theme add <repo>@<ref> Install a web UI theme (list, validate, remove)",

package/src/ui/cli/server-agent-ops.ts

@@ -25,9 +25,9 @@ import {
   type AgentsResolved,
   type RuntimeChoice,
   type Started,
+  rotationOf,
 } from "./agent-ops.js";
 import { readRecord } from "../../shared/agents/records.js";
-import { rotationInfo } from "../../shared/agents/rotation.js";
 import {
   SERVER_AGENT_ID,
   SERVER_PERSONA_ID,
@@ -355,7 +355,7 @@ export async function startServerAgent(
     rec.runtime === runtime &&
     rec.model === model
   ) {
-    if (rotationInfo(d.stateDir(), rec)?.ready)
+    if (rotationOf(d, rec)?.ready)
       return done("relaunched", await relaunchAgent(d, rec.id));
     if (resumeRefusal(rec) === null)
       return done("resumed", await resumeAgent(d, rec.id, SERVER_SCOPE));