@monster-orange/den 0.4.22 → 0.4.23

package/src/ui/server/agent-routes.ts

@@ -99,8 +99,10 @@ import {
 import {
   readWorkspacesFile,
   conversationFolders,
+  listWorkspaceServices,
   resolveWorkspaceDir,
 } from "../../shared/environment-manager/workspaces.js";
+import { readCatalog } from "../../shared/environment-manager/catalog.js";
 import { getStateDir } from "../../shared/paths.js";
 import { HostError } from "../../shared/sessions/client.js";
 import {
@@ -133,7 +135,13 @@ import {
   changePersona,
   listConversations,
   relaunchAgent,
-  resumeAgent,
+  resumeOrRelaunch,
+  keepAgentConversation,
+  askForHandoff,
+  rotationSettings,
+  setRotationSetting,
+  rotationTick,
+  ROTATION_TICK_MS,
   startAgent,
   startFresh,
   stopAgent,
@@ -167,7 +175,7 @@ export interface AgentRouteDeps {
 }
 
 const AGENTS_PATH =
-  /^\/api\/workspaces\/([^/]+)\/agents(?:\/([^/]+)\/(stop|resume|fresh|relaunch|remove|name|paths|persona))?$/;
+  /^\/api\/workspaces\/([^/]+)\/agents(?:\/([^/]+)\/(stop|resume|fresh|relaunch|remove|name|paths|persona|keep|handoff))?$/;
 
 const RUNTIME_PATH = /^\/api\/agents\/runtimes\/([^/]+)\/path$/;
 const PERSONA_PATH = /^\/api\/personas\/([^/]+)$/;
@@ -203,6 +211,15 @@ export function webDeps(over: AgentsDeps = {}): AgentsResolved {
             return conversationFolders(ws, cfg, getReposRoot());
           },
         }),
+    // D28: the service scope of rotation settings.
+    workspaceServices: (ws) => {
+      const cfg = readWorkspacesFile().workspaces[ws];
+      if (!cfg) return [];
+      return listWorkspaceServices(cfg, readCatalog(), ws).map((r) => ({
+        address: r.address,
+        path: r.repoPath,
+      }));
+    },
     stdout: NO_TTY,
     out: () => undefined,
     err: () => undefined,
@@ -406,6 +423,8 @@ export async function handleAgentRoutes(
     pathname === "/api/agents/clear-stopped" ||
     pathname === "/api/agents/restore" ||
     pathname === "/api/agents/resume-interrupted";
+  if (pathname === "/api/agents/rotation")
+    return rotationRoute(req, res, webDeps(deps.agents));
   if (
     pathname !== "/api/personas" &&
     pathname !== "/api/agents/runtimes" &&
@@ -490,6 +509,8 @@ export async function handleAgentRoutes(
     | "name"
     | "paths"
     | "persona"
+    | "keep"
+    | "handoff"
     | undefined;
 
   if (!action && method === "GET") {
@@ -571,6 +592,12 @@ export async function handleAgentRoutes(
         "only a person can change an agent's persona (an agent can't change its own or another's)",
         { status: 403 },
       );
+    // D28: an agent could keep itself from ever rotating.
+    if (verb === "keep" && (agent || actor))
+      throw new AgentError(
+        "only a person can keep an agent's conversation past its rotation",
+        { status: 403 },
+      );
     if (verb === "resume" && agent) {
       const why = agentResumeRefusal(agent, ws, id!, mcpActions());
       if (why) throw new AgentError(why, { status: 403 });
@@ -651,6 +678,38 @@ export async function handleAgentRoutes(
       what = `start ${s.rec.id} fresh (${s.rec.persona}, ${s.rec.runtime}) in ${ws}`;
       audit(what, s.early ? "exited at once" : undefined);
       sendStarted(res, s, d);
+    } else if (verb === "keep") {
+      const body = await jsonBody(req);
+      for (const k of Object.keys(body))
+        if (k !== "never")
+          throw new AgentError(`${k}: unknown field (keep takes never)`, {
+            usage: true,
+          });
+      if (body.never !== undefined && typeof body.never !== "boolean")
+        throw new AgentError("never must be true or false", { usage: true });
+      const rec = keepAgentConversation(d, id!, ws, {
+        never: body.never === true,
+      });
+      what = `keep ${rec.id}'s conversation in ${ws}${body.never ? " (never rotate)" : ""}`;
+      audit(what);
+      sendJson(res, { ok: true, agent: rec.id, never: body.never === true });
+    } else if (verb === "handoff") {
+      const body = await jsonBody(req);
+      for (const k of Object.keys(body))
+        if (k !== "relaunch")
+          throw new AgentError(`${k}: unknown field (handoff takes relaunch)`, {
+            usage: true,
+          });
+      const relaunch = body.relaunch === true;
+      const rec = await askForHandoff(d, id!, ws, undefined, { relaunch });
+      what = `ask ${rec.id} for its handoff in ${ws}${relaunch ? ", then relaunch" : ""}${rec.resumed ? " (resumed to write it)" : ""}`;
+      audit(what);
+      sendJson(res, {
+        ok: true,
+        agent: rec.id,
+        relaunch,
+        ...(rec.resumed ? { resumed: true } : {}),
+      });
     } else if (verb === "relaunch") {
       const s = await relaunchAgent(d, id!, ws);
       what = `relaunch ${s.rec.id} from its handoff (${s.why}) in ${ws}`;
@@ -732,9 +791,16 @@ export async function handleAgentRoutes(
       audit(what);
       sendJson(res, { ok: true, removed });
     } else {
-      const s = await resumeAgent(d, id!, ws);
-      audit(what);
-      sendStarted(res, s, d);
+      // D28: a due agent under auto relaunches from its handoff instead.
+      const r = await resumeOrRelaunch(d, id!, ws);
+      if (r.kind === "relaunched") {
+        what = `relaunch ${r.s.rec.id} from its handoff (${r.s.why}) in ${ws}, on Resume`;
+        audit(what, r.s.early ? "exited at once" : undefined);
+        sendStarted(res, r.s, d, { relaunched: true });
+      } else {
+        audit(what);
+        sendStarted(res, r.s, d);
+      }
     }
   } catch (e) {
     audit(what, e instanceof Error ? e.message : String(e));
@@ -1209,8 +1275,86 @@ export function startAgentUpkeep(
       log(`  ⚠ agents.remove_stopped_after: ${(e as Error).message}`);
     }
   };
+  // D28: due agents under on_due auto, at idle: asked for the handoff,
+  // then relaunched from it. One look at a time.
+  let looking = false;
+  const rotate = async () => {
+    if (looking) return;
+    looking = true;
+    try {
+      for (const e of await rotationTick(d)) {
+        const who = `${e.agent} in ${e.workspace}`;
+        if (e.kind === "relaunched") {
+          const what = `relaunch ${who} from its handoff (${e.why}), by itself; the old conversation ${e.old ?? "?"} is kept`;
+          recordAction(null, { verb: "agents", detail: what });
+          log(`Relaunched ${who} from its handoff after ${e.why}`);
+        } else if (e.kind === "asked")
+          log(`Asked ${who} for its handoff (${e.asked} of 2)`);
+        else if (e.kind === "fell-back")
+          log(
+            `  ⚠ ${who} wrote no handoff after 2 asks: its callout asks the person`,
+          );
+        else log(`  ⚠ rotation of ${who}: ${e.why}`);
+      }
+    } catch (e) {
+      log(`  ⚠ agents.rotate: ${(e as Error).message}`);
+    } finally {
+      looking = false;
+    }
+  };
   setTimeout(() => {
     void restart().then(prune);
   }, deps.delayMs ?? 2000).unref();
   setInterval(() => void prune(), PRUNE_EVERY_MS).unref();
+  setInterval(() => void rotate(), ROTATION_TICK_MS).unref();
+}
+
+/**
+ * D28, `/api/agents/rotation`. GET: the settings (install, overrides,
+ * defaults) and, with `?ws=&agent=`, that agent's effective values and
+ * where each comes from. PUT `{ scope, target?, key, value }` sets one
+ * (value null clears it): a person's only.
+ */
+async function rotationRoute(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  d: AgentsResolved,
+): Promise<boolean> {
+  const method = req.method ?? "GET";
+  try {
+    if (method === "GET" || method === "HEAD") {
+      const q = new URL(req.url ?? "/", "http://localhost").searchParams;
+      const ws = q.get("ws") ?? undefined;
+      const agent = q.get("agent") ?? undefined;
+      if ((ws && !NAME_RE.test(ws)) || (agent && !NAME_RE.test(agent)))
+        throw new AgentError("not a name", { usage: true });
+      sendJson(res, rotationSettings(d, agent, ws));
+      return true;
+    }
+    if (method !== "PUT") return methodNotAllowed(res, "GET, PUT");
+    if (agentPrincipalOf(req) || auditActorOf(req))
+      throw new AgentError("only a person can change rotation settings", {
+        status: 403,
+      });
+    const body = await jsonBody(req);
+    for (const k of Object.keys(body))
+      if (!["scope", "target", "key", "value"].includes(k))
+        throw new AgentError(
+          `${k}: unknown field (takes scope, target, key, value)`,
+          { usage: true },
+        );
+    const out = setRotationSetting(d, body);
+    recordAction(
+      null,
+      {
+        verb: "agents",
+        detail: `rotation ${String(body.scope)}${body.target ? ` ${String(body.target)}` : ""} ${String(body.key)} = ${body.value === null ? "(unset)" : JSON.stringify(body.value)}`,
+      },
+      principalOf(req),
+    );
+    sendJson(res, { ok: true, ...out });
+  } catch (e) {
+    sendError(res, e);
+  }
+  return true;
 }

package/src/ui/server/index.ts

@@ -868,7 +868,12 @@ import {
 import { heldActions } from "./held-actions.js";
 import type { ApprovalQueue } from "./approvals.js";
 import { processPathRules } from "../cli/onboard-reads.js";
-import { handleAgentRoutes, startAgentUpkeep } from "./agent-routes.js";
+import {
+  handleAgentRoutes,
+  startAgentUpkeep,
+  webDeps as agentWebDeps,
+} from "./agent-routes.js";
+import { policyResolver } from "../cli/agent-ops.js";
 import { handleServerAgentRoutes } from "./server-agent-routes.js";
 import { freshDen } from "../cli/server-agent-ops.js";
 import {
@@ -4748,7 +4753,10 @@ async function handleRequest(
       res,
       pathname,
       guard.ok && (!guard.beyond || !!guard.session || !!guard.principal),
-      { waitingAgents: waitingAgentIds },
+      {
+        waitingAgents: waitingAgentIds,
+        rotationPolicy: () => policyResolver(agentWebDeps()),
+      },
     )
   )
     return;
@@ -5579,9 +5587,9 @@ server.on("error", (err: NodeJS.ErrnoException) => {
   if (err.code === "EADDRINUSE") {
     console.error(
       `\n  ✗ Port ${PORT} is already in use.\n` +
-        `\n  Another ${product().cli} instance may be running. To fix:\n` +
-        `\n    lsof -ti :${PORT} | xargs kill   # kill whatever is on the port` +
-        `\n    make web                          # then restart\n`,
+        `\n  Another ${product().cli} server may be running, or its service holds the port.` +
+        `\n  ${product().cli} service status   # is the service running it?` +
+        `\n  ${product().cli} web restart      # restarts the service, or the plain server\n`,
     );
     process.exit(1);
   }

package/src/ui/server/public/agents-page.js

@@ -368,10 +368,98 @@ function whereTag(r, button = false) {
 
 /** Its rotation, when one is due: "ready" or "due" (den#4). */
 function rotationOf(r) {
-  if (!r.rotation?.due) return "";
+  // D28: on_due off: nothing will happen, so nothing is shown.
+  if (!r.rotation?.due || r.rotation.onDue === "off") return "";
   return r.rotation.ready ? "ready" : "due";
 }
 
+/** D28: Settings › Agents (its Rotation row). */
+function settingsHref() {
+  const nav = window.denShell?.nav?.() ?? [];
+  const base = nav.find((n) => n.id === "settings")?.href ?? "/settings";
+  return `${base}?q=rotation#agents`;
+}
+
+/**
+ * D28: what happens to a due agent, in words, from its on_due (auto: Den
+ * asks for the handoff at idle and relaunches it; ask; auto that gave up
+ * asking). Older servers send no on_due: as ask.
+ */
+function rotMessage(r) {
+  const rot = r.rotation;
+  const why = rotationWhy(rot);
+  const auto = rot.onDue === "auto" && !rot.fellBack;
+  if (rot.relaunchWanted && !rot.ready) return t("ag.rc.wanted", { why });
+  if (auto && !isStopped(r))
+    return t(rot.ready ? "ag.rc.autoReady" : "ag.rc.autoAsk", { why });
+  if (rot.fellBack && !rot.ready)
+    return t(
+      rot.handoff === "invalid" ? "ag.rc.fellBackBad" : "ag.rc.fellBack",
+      { why },
+    );
+  return t(
+    rot.ready
+      ? "ag.rc.ready"
+      : rot.handoff === "invalid"
+        ? "ag.rc.bad"
+        : "ag.rc.missing",
+    { why },
+  );
+}
+
+/**
+ * D28: the rotation callout's buttons, wherever it shows (a row, the pane
+ * bar): Relaunch now (from the handoff, or asking for it first), Write
+ * handoff (a running agent without one), Keep this conversation with
+ * "don't ask again", and Settings. "" when nothing is due or on_due is off.
+ */
+function rotActionsHtml(r) {
+  const rot = r.rotation;
+  if (!rot?.due || rot.onDue === "off") return "";
+  const id = r.agent;
+  const now = `<button type="button" class="den-btn sm primary" data-act="relaunch" aria-label="${esc(t("ag.relaunchName", { id }))}">${esc(t("ag.relaunch"))}</button>`;
+  const write =
+    !isStopped(r) && !rot.ready && !rot.relaunchWanted
+      ? `<button type="button" class="den-btn sm" data-act="rot-write" aria-label="${esc(t("ag.rc.writeName", { id }))}">${esc(t("ag.rc.write"))}</button>`
+      : "";
+  const keep = `<button type="button" class="den-btn sm" data-act="rot-keep" aria-label="${esc(t("ag.rc.keepName", { id }))}">${esc(t("ag.rc.keep"))}</button>`;
+  const never = `<label class="agnever"><input type="checkbox" data-rot-never> ${esc(t("ag.rc.never"))}</label>`;
+  const settings = `<a class="lnk" data-rot-settings href="${esc(settingsHref())}">${esc(t("ag.rc.settings"))}</a>`;
+  return now + write + keep + never + settings;
+}
+
+/** D28: the effective settings and where each comes from, in words. */
+function rotFromText(rot) {
+  if (!rot?.from) return "";
+  return t(
+    rot.after === 0
+      ? "ag.rc.fromNever"
+      : rot.after === 1
+        ? "ag.rc.from.one"
+        : "ag.rc.from",
+    {
+      n: rot.after,
+      src: rot.from.after_compactions,
+      mode: t(`ag.rc.mode.${rot.onDue}`),
+      src2: rot.from.on_due,
+    },
+  );
+}
+
+/** D28: the callout under a row: the message, its line of settings, the buttons. */
+function rotCalloutHtml(r) {
+  const acts = rotActionsHtml(r);
+  if (!acts) return "";
+  const from = rotFromText(r.rotation);
+  return (
+    `<span class="agcant" data-rot-msg data-handoff="${esc(r.rotation.handoff)}">${esc(rotMessage(r))}</span>` +
+    (from
+      ? `<span class="agcant agfrom" data-rot-from>${esc(from)}</span>`
+      : "") +
+    acts
+  );
+}
+
 /** A stopped agent's row: its button (it opens an ended pane) and actions. */
 function stoppedHtml(r) {
   const open = st.open.includes(r.id);
@@ -380,10 +468,8 @@ function stoppedHtml(r) {
   const meta = [r.runtime, r.cwd].filter(Boolean).join(" · ");
   const who = esc(r.agent);
   const rot = rotationOf(r);
-  const relaunch =
-    rot === "ready"
-      ? `<button type="button" class="den-btn sm primary" data-act="relaunch" aria-label="${esc(t("ag.relaunchName", { id: r.agent }))}">${esc(t("ag.relaunch"))}</button>`
-      : "";
+  // D28: a due agent's callout (unless on_due is off).
+  const callout = rotCalloutHtml(r);
   const resume = r.resumable
     ? `<button type="button" class="den-btn sm primary" data-act="resume" aria-label="${esc(t("ag.resumeName", { id: r.agent }))}">${esc(t("ag.resume"))}</button>`
     : "";
@@ -391,18 +477,6 @@ function stoppedHtml(r) {
   const remove = `<button type="button" class="den-btn sm" data-act="remove" aria-label="${esc(t("ag.removeName", { id: r.agent }))}">${esc(t("ag.remove"))}</button>`;
   // D25: an agent with no pane open can be renamed too.
   const rename = `<button type="button" class="den-btn sm" data-act="rename" aria-label="${esc(t("ag.renameName", { id: r.agent }))}">${esc(t("ag.rn.act"))}</button>`;
-  // A rotation due without a handoff that passes: say so (den#4).
-  const handoff =
-    rot === "due"
-      ? `<span class="agcant" data-handoff="${esc(r.rotation.handoff)}">${esc(
-          t(
-            r.rotation.handoff === "missing"
-              ? "ag.rot.noHandoff"
-              : "ag.rot.badHandoff",
-            { why: rotationWhy(r.rotation) },
-          ),
-        )}</span>`
-      : "";
   const cant =
     !r.resumable && r.noResume && rot !== "ready"
       ? `<span class="agcant" data-no-resume>${esc(r.noResume.startsWith(`${r.runtime} `) ? t("ag.noResume", { runtime: r.runtime }) : r.noResume)}</span>`
@@ -421,7 +495,7 @@ function stoppedHtml(r) {
     (meta ? `<span class="meta">${esc(meta)}</span>` : "") +
     `<span class="why">${esc(stopReason(r))}</span>` +
     `</button>` +
-    `<div class="agacts">${handoff}${cant}${relaunch}${resume}${fresh}${rename}${remove}</div>` +
+    `<div class="agacts">${callout}${cant}${resume}${fresh}${rename}${remove}</div>` +
     `</div>`
   );
 }
@@ -454,7 +528,7 @@ function rowHtml(r) {
     rotTag || revokedTag || ovTags || wTag
       ? `<span class="agtags">${revokedTag}${rotTag}${wTag}${ovTags}</span>`
       : "";
-  return (
+  const button =
     `<button type="button" class="agr" data-id="${esc(r.id)}" data-kind="${esc(r.kind)}" data-state="${esc(r.state)}"` +
     ` aria-pressed="${open}"${r.attachable ? "" : ' aria-disabled="true"'}` +
     ` aria-label="${esc(t("ag.openName", { id: `${r.workspace} / ${displayName(r)}` }))}">` +
@@ -462,7 +536,16 @@ function rowHtml(r) {
     `<span class="nm">${nm}</span>${right}` +
     (meta ? `<span class="meta">${esc(meta)}</span>` : "") +
     tags +
-    `</button>`
+    `</button>`;
+  // D28: a running agent whose rotation is due: its callout, with buttons
+  // (before, only a tag: nothing to press).
+  const callout = r.kind === "agent" ? rotCalloutHtml(r) : "";
+  if (!callout) return button;
+  return (
+    `<div class="agst" data-agent="${esc(r.agent)}" data-state="${esc(r.state)}" data-ws="${esc(r.workspace)}" data-rotation="${rot}">` +
+    button +
+    `<div class="agacts">${callout}</div>` +
+    `</div>`
   );
 }
 
@@ -608,6 +691,7 @@ async function refresh() {
     } else if (r.ok) {
       st.data = await r.json();
       st.signedOut = false;
+      toastAutoRelaunches(st.data?.sessions ?? []);
     }
   } catch {
     /* the last list stays; the next ask may answer */
@@ -1011,6 +1095,9 @@ function paintBar(p) {
       ? `<span class="tagx warn" title="${esc(t("ag.revokedTip"))}">${esc(t("ag.revoked"))}</span>`
       : "") +
     whereTag(r, true) +
+    (r?.kind === "agent" && rotActionsHtml(r)
+      ? `<span class="agrot" data-rot-bar title="${esc(rotMessage(r))}"><span class="tagx warn" data-rotation="${rotationOf(r)}">${esc(t(rotationOf(r) === "ready" ? "ag.rot.ready" : "ag.rot.due", { why: rotationWhy(r.rotation) }))}</span>${rotActionsHtml(r)}</span>`
+      : "") +
     `<span class="x">${reconnect}${stop}${resume}${more}<button type="button" class="den-btn sm" data-act="close" aria-label="${esc(t("ag.detachName", { id: name }))}" title="${esc(t("ag.detach"))}">×</button></span>`;
   // Tabs: the tab's × closes it; the pane's bar has none.
   const x = bar.querySelector('[data-act="close"]');
@@ -1518,6 +1605,93 @@ async function restartRow(r, verb, button) {
   }
 }
 
+/**
+ * D28 Relaunch now: from the handoff when it passes; else Den asks for it
+ * first (a stopped agent resumes to write it) and relaunches it once it
+ * passes, by itself.
+ */
+async function relaunchNow(r, button) {
+  if (r.rotation?.ready) return restartRow(r, "relaunch", button);
+  if (button) button.disabled = true;
+  try {
+    const out = await api("POST", agentPath(r, "handoff"), { relaunch: true });
+    window.denShell?.toast?.(
+      t(out?.resumed ? "ag.rc.askedResumed" : "ag.rc.askedRelaunch", {
+        id: r.agent,
+      }),
+    );
+  } catch (err) {
+    window.denShell?.errorToast?.(err);
+  }
+  await refresh();
+}
+
+/** D28 Write handoff: the prompt, typed into its session at idle. */
+async function writeHandoff(r, button) {
+  if (button) button.disabled = true;
+  try {
+    await api("POST", agentPath(r, "handoff"), {});
+    window.denShell?.toast?.(t("ag.rc.asked", { id: r.agent }));
+  } catch (err) {
+    // Mid-turn is expected, not an error: say when to try again.
+    if (/mid-turn/.test(String(err?.message ?? "")))
+      window.denShell?.toast?.(t("ag.rc.midTurn", { id: r.agent }));
+    else window.denShell?.errorToast?.(err);
+  }
+  await refresh();
+}
+
+/** D28 Keep this conversation (and "don't ask again": never, for it). */
+async function keepConversation(r, button) {
+  const never = !!button
+    ?.closest(".agacts, .agrot")
+    ?.querySelector("[data-rot-never]")?.checked;
+  if (button) button.disabled = true;
+  try {
+    await api("POST", agentPath(r, "keep"), never ? { never: true } : {});
+    window.denShell?.toast?.(
+      t(never ? "ag.rc.keptNever" : "ag.rc.kept", { id: r.agent }),
+    );
+  } catch (err) {
+    window.denShell?.errorToast?.(err);
+  }
+  await refresh();
+}
+
+/**
+ * D28: a relaunch Den did by itself since the last look: a toast saying
+ * so, and that the old conversation is kept. The first look only notes
+ * what is there.
+ */
+function toastAutoRelaunches(rows) {
+  const seen = (st.rotSeen ??= new Map());
+  const first = !st.rotLooked;
+  st.rotLooked = true;
+  for (const r of rows) {
+    const last = r.kind === "agent" ? r.lastRotation : undefined;
+    if (!last) continue;
+    const key = `${r.workspace}/${r.agent}`;
+    if (seen.get(key) === last.at) continue;
+    seen.set(key, last.at);
+    if (first || !last.auto) continue;
+    window.denShell?.toast?.(
+      t("ag.rc.autoRelaunched", {
+        id: r.agent,
+        why:
+          last.reason === "pr-merged"
+            ? t("ag.rot.merged")
+            : t(
+                last.compactions === 1
+                  ? "ag.rot.compactions.one"
+                  : "ag.rot.compactions",
+                { n: last.compactions },
+              ),
+        old: last.conversation ?? "?",
+      }),
+    );
+  }
+}
+
 /** Undo: the removed agents come back (POST /api/agents/restore). */
 async function undoRemove(ids) {
   try {
@@ -2786,7 +2960,10 @@ export async function mountAgentsPage(root) {
         (x) => x.agent === agent && x.workspace === ws,
       );
       if (!r) return;
-      if (which === "resume" || which === "fresh" || which === "relaunch")
+      if (which === "relaunch") void relaunchNow(r, act);
+      else if (which === "rot-write") void writeHandoff(r, act);
+      else if (which === "rot-keep") void keepConversation(r, act);
+      else if (which === "resume" || which === "fresh")
         void restartRow(r, which, act);
       else if (which === "remove") void removeRow(r, act);
       else if (which === "rename") openRename(r, act);
@@ -2826,7 +3003,14 @@ export async function mountAgentsPage(root) {
       return;
     }
     if (b.dataset.act === "close") closePane(id);
-    else if (b.dataset.act === "stop") void stopAgent(p, b);
+    else if (b.dataset.act === "relaunch" || b.dataset.act.startsWith("rot-")) {
+      // D28: the callout's buttons in the pane bar.
+      const r = rowOf(id);
+      if (!r) return;
+      if (b.dataset.act === "relaunch") void relaunchNow(r, b);
+      else if (b.dataset.act === "rot-write") void writeHandoff(r, b);
+      else if (b.dataset.act === "rot-keep") void keepConversation(r, b);
+    } else if (b.dataset.act === "stop") void stopAgent(p, b);
     else if (b.dataset.act === "resume") {
       const r = rowOf(id);
       if (r) void restartRow(r, "resume", b);
@@ -2840,6 +3024,14 @@ export async function mountAgentsPage(root) {
           // D25: a visible Rename, for touch and keyboard (not only a
           // double-click on a tab).
           { label: t("ag.rn.item"), onSelect: () => openRename(r, b) },
+          // D28: its rotation settings and where each comes from.
+          {
+            label: t("ag.rc.menu"),
+            onSelect: () =>
+              window.denShell?.toast?.(
+                rotFromText(r.rotation) || t("ag.rc.noState"),
+              ),
+          },
           ...(r.personaChange
             ? [
                 {

package/src/ui/server/public/agents.html

@@ -233,6 +233,38 @@
         font: 12px/1.4 var(--sans);
         color: var(--faint);
       }
+      /* D28: the rotation callout: its message, its settings, its buttons. */
+      .agst .agcant[data-rot-msg] {
+        color: var(--warn-text, var(--text));
+      }
+      .agst .agfrom {
+        font-size: 11.5px;
+      }
+      .agnever {
+        display: inline-flex;
+        align-items: center;
+        gap: 4px;
+        font: 12px/1.4 var(--sans);
+        color: var(--muted);
+      }
+      /* The callout takes a line of its own under the bar's name and
+         buttons, so it never runs under Stop (375 px). */
+      .pane .bar2:has(.agrot) {
+        flex-wrap: wrap;
+        row-gap: 4px;
+      }
+      .bar2 .agrot {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 4px;
+        min-width: 0;
+        order: 10;
+        flex: 1 1 100%;
+      }
+      .bar2 .agrot .agnever {
+        display: none;
+      }
       .agst[data-review] > .agr {
         border-left-color: var(--warn);
       }