harnery 0.42.0 → 0.44.0

package/src/commands/agents.ts

@@ -50,13 +50,6 @@ import {
   LiveCoordinationAuthorityV3Error,
   reopenLiveCoordinationGenerationV3,
 } from "../core/agents/live-authority-v3.ts";
-import {
-  isAddressableName,
-  MailboxCapacityError,
-  type QueueResult,
-  queueMailboxMessage,
-  suggestNames,
-} from "../core/agents/mailbox.ts";
 import { qaSignalStatusRow } from "../core/agents/qa-signal.ts";
 import { reconcileCoordinationV3 } from "../core/agents/reconcile-coordination-v3.ts";
 import {
@@ -84,6 +77,7 @@ import {
   readLiveCoordinationRow,
   readLiveCoordinationRows,
 } from "../core/agents/state/live-coordination-view.ts";
+import { forkRelationLabels, resolveForkAncestry } from "../core/agents/state/names.ts";
 import {
   type AgentActivity,
   foldSessionState,
@@ -107,6 +101,7 @@ import {
   projectCoordinationViewV3,
   readCoordinationViewV3,
 } from "../core/events/v3/coordination-view.ts";
+import { nativeInstanceIdV3 } from "../core/events/v3/live-route-observer.ts";
 import { liveInstanceIdV3 } from "../core/events/v3/live-routing.ts";
 import {
   countSummarizedSinceV3,
@@ -128,9 +123,12 @@ import {
   readRuntimeContextTelemetry,
   readRuntimeContextUsage,
 } from "../core/hooks/adapter/runtime-telemetry.ts";
+import { HarneryInboxCapacityError } from "../core/inbox/contract.ts";
+import { peerInbox, sendPeerMessage } from "../core/inbox/peer-messages.ts";
 import { type RemoteMachine, readRemoteMachines } from "../core/presence/index.ts";
 import { formatResourceSummary, readResourceStatus } from "../core/resources/status.ts";
 import { registerContextCommand } from "./context.ts";
+import { registerInboxCommand } from "./inbox.ts";
 
 type LiveCoordinationRow = ReturnType<typeof readLiveCoordinationRows>[number];
 
@@ -311,6 +309,11 @@ export function registerAgentsCommand(
     );
 
   registerContextCommand(cmd, emitParam, programContext);
+  registerInboxCommand(cmd, emitParam, peerInbox(monorepoRoot() ?? process.cwd()), () => {
+    const owner = resolveOwner();
+    if (!owner) throw new Error("recipient instance is required outside an agent session");
+    return owner;
+  });
 
   cmd
     .command("whoami")
@@ -437,9 +440,15 @@ export function registerAgentsCommand(
       "--session-id <id>",
       "Target the heartbeat with this session_id directly, bypassing the ppid walk.",
     )
-    .action((state: string, opts: { reason?: string; sessionId?: string }) => {
-      runLifecycle(state, opts);
-    });
+    .option(
+      "--force-ancestor",
+      "Allow a fork to change its fork ancestor's lifecycle (only on explicit operator instruction)",
+    )
+    .action(
+      (state: string, opts: { reason?: string; sessionId?: string; forceAncestor?: boolean }) => {
+        runLifecycle(state, opts);
+      },
+    );
 
   cmd
     .command("end")
@@ -453,9 +462,20 @@ export function registerAgentsCommand(
       "succeeded | failed | cancelled | timed_out | denied | interrupted | unknown",
       "succeeded",
     )
-    .action((opts: { sessionId?: string; instanceId?: string; outcome: string }) => {
-      runEndSession(opts);
-    });
+    .option(
+      "--force-ancestor",
+      "Allow a fork to finalize its fork ancestor's session (only on explicit operator instruction)",
+    )
+    .action(
+      (opts: {
+        sessionId?: string;
+        instanceId?: string;
+        outcome: string;
+        forceAncestor?: boolean;
+      }) => {
+        runEndSession(opts);
+      },
+    );
 
   cmd
     .command("reconcile")
@@ -511,15 +531,22 @@ export function registerAgentsCommand(
   cmd
     .command("ping <name> <message...>")
     .description(
-      "Send a message to another agent by name. Works whether or not that agent " +
-        "is running: a live peer sees it on their next prompt, and a name with no " +
-        "live session gets it queued until a session of that name next starts. " +
-        "Only an unknown name is refused.",
+      "Queue a durable message for one known task instance by name. Stale or " +
+        "done tasks receive it when that same task resumes. Ambiguous names " +
+        "require an exact instance; receipts do not confirm attention.",
     )
+    .option("--instance-id <id>", "Select the exact known recipient instance")
+    .option("--require-live", "Refuse a recipient outside live presence")
     .option("--json", "JSON output")
-    .action((name: string, message: string[], opts: { json?: boolean }) => {
-      runPing(name, message.join(" "), opts);
-    });
+    .action(
+      (
+        name: string,
+        message: string[],
+        opts: { json?: boolean; instanceId?: string; requireLive?: boolean },
+      ) => {
+        runPing(name, message.join(" "), opts);
+      },
+    );
 
   cmd
     .command("wait <name>")
@@ -666,7 +693,40 @@ const SESSION_OUTCOMES = new Set([
   "unknown",
 ]);
 
-function runEndSession(opts: { sessionId?: string; instanceId?: string; outcome: string }) {
+/**
+ * Refuse when the calling session targets one of its recorded fork ancestors.
+ * A fork's transcript is full of its parent's name, task, and claims, so a
+ * fork that "cleans up its earlier self" is usually cutting off a live parent
+ * (2026-10-07: a fork offered to close its running parent). Returns the
+ * refusal message, or null when the call may proceed.
+ */
+function forkAncestorRefusal(
+  root: string,
+  targetIds: Array<string | undefined>,
+  force: boolean | undefined,
+  action: string,
+): string | null {
+  if (force) return null;
+  const ids = new Set(targetIds.filter((id): id is string => !!id));
+  if (ids.size === 0) return null;
+  const self = resolveOwner() ?? sessionIdentityFromEnv();
+  if (!self || ids.has(self)) return null;
+  const ancestor = resolveForkAncestry(root, self).find((a) => ids.has(a.instance_id));
+  if (!ancestor) return null;
+  const label = ancestor.name ? `agent-${ancestor.name}` : ancestor.instance_id;
+  return (
+    `${label} is this session's fork ancestor: this conversation was branched from it, so its ` +
+    `name, task, and files in your context are its own, and it may still be running. Refusing to ` +
+    `${action} it. Rerun with --force-ancestor only when the operator explicitly asked for that.`
+  );
+}
+
+function runEndSession(opts: {
+  sessionId?: string;
+  instanceId?: string;
+  outcome: string;
+  forceAncestor?: boolean;
+}) {
   const root = monorepoRoot();
   if (!root) return failCommand("not_in_repo", "not in an agent session");
   if (!SESSION_OUTCOMES.has(opts.outcome)) {
@@ -698,6 +758,15 @@ function runEndSession(opts: { sessionId?: string; instanceId?: string; outcome:
     return failCommand("session_identity_missing", "live V3 generation disappeared");
   }
   const state = record.state;
+  if (opts.instanceId || opts.sessionId) {
+    const refusal = forkAncestorRefusal(
+      root,
+      [target, state.session_id, nativeInstanceIdV3(state.instance_id)],
+      opts.forceAncestor,
+      "finalize",
+    );
+    if (refusal) return failCommand("session_is_fork_ancestor", refusal);
+  }
   if (state.delegations.length > 0) {
     return failCommand(
       "session_work_open",
@@ -1992,7 +2061,10 @@ function runSetTask(task: string, opts?: { sessionId?: string }): void {
   });
 }
 
-function runLifecycle(rawState: string, opts: { reason?: string; sessionId?: string }): void {
+function runLifecycle(
+  rawState: string,
+  opts: { reason?: string; sessionId?: string; forceAncestor?: boolean },
+): void {
   const state = rawState.trim().toLowerCase();
   if (state !== "active" && state !== "blocked" && state !== "done") {
     emit.error({
@@ -2013,6 +2085,19 @@ function runLifecycle(rawState: string, opts: { reason?: string; sessionId?: str
     return;
   }
   if (!opts.sessionId) ensureAdapterSession(root);
+  if (opts.sessionId) {
+    const refusal = forkAncestorRefusal(
+      root,
+      [opts.sessionId],
+      opts.forceAncestor,
+      "change the lifecycle of",
+    );
+    if (refusal) {
+      emit.error({ code: "session_is_fork_ancestor", message: refusal });
+      process.exitCode = 1;
+      return;
+    }
+  }
   const myOwner = opts.sessionId ?? resolveOwner() ?? sessionIdentityFromEnv();
   if (!myOwner) {
     emit.error(
@@ -2390,8 +2475,15 @@ function runStatus(opts: {
 
   const { livePeers, stale: peersStale } = collectStatusPeerHealth(root, myOwner);
 
-  // Sort: file-holders first (by file count desc), then idle peers by recency.
+  // Recorded fork relations label the parent and forks so a fork cannot read
+  // its live parent as its own earlier session; they sort first.
+  const relations = forkRelationLabels(root, myOwner, new Set(livePeers.map((p) => p.instance_id)));
+  // Sort: related sessions, then file-holders (by file count desc), then idle
+  // peers by recency.
   livePeers.sort((a, b) => {
+    const ar = relations.has(a.instance_id) ? 1 : 0;
+    const br = relations.has(b.instance_id) ? 1 : 0;
+    if (ar !== br) return br - ar;
     const af = a.files_touched?.length ?? 0;
     const bf = b.files_touched?.length ?? 0;
     if (af !== bf) return bf - af;
@@ -2406,7 +2498,7 @@ function runStatus(opts: {
   );
   // Cross-machine presence (ADR 0016): sessions on other machines, advisory.
   const remoteMachines = readRemoteMachines(root);
-  const peersStr = formatPeers(livePeers, 4, peersStale, remoteMachines);
+  const peersStr = formatPeers(livePeers, 4, peersStale, remoteMachines, relations);
 
   const ctxUsage = readContextUsage(hb.native_session_id ?? hb.session_id, hb.platform);
   let ctxStr: string;
@@ -2600,13 +2692,15 @@ function formatPeers(
   cap: number,
   staleCount: number,
   remoteMachines: RemoteMachine[] = [],
+  relations: Map<string, string> = new Map(),
 ): string {
   if (peers.length === 0 && staleCount === 0 && remoteMachines.length === 0) return "none";
   const labels = peers.map((p) => {
     const name = p.name || "unnamed";
     const plat = formatPlatformLabel(p.platform);
     const files = p.files_touched?.length ?? 0;
-    const base = `${name} (${plat})`;
+    const relation = relations.get(p.instance_id);
+    const base = relation ? `${name} (${plat}, ${relation})` : `${name} (${plat})`;
     return files > 0 ? `${base}, ${files} files` : base;
   });
   let main: string;
@@ -4784,7 +4878,11 @@ function formatDuration(ms: number): string {
   return h > 0 ? `${d}d${h}h` : `${d}d`;
 }
 
-function runPing(name: string, message: string, opts: { json?: boolean }): void {
+function runPing(
+  name: string,
+  message: string,
+  opts: { json?: boolean; instanceId?: string; requireLive?: boolean },
+): void {
   if (!message || message.trim().length === 0) {
     emit.error({ code: "empty_message", message: "message is required (and non-empty)" });
     process.exit(1);
@@ -4805,52 +4903,33 @@ function runPing(name: string, message: string, opts: { json?: boolean }): void
     );
     process.exit(1);
   }
-  const coordRoot = monorepoRoot();
-  const peerOwner = resolveOwnerByName(name);
-
-  // A name with no live session is the common case, not an error: the agent it
-  // refers to may have ended minutes ago and may come back under the same name.
-  // Refuse only a name that no agent has ever held, which is a typo — queueing
-  // that would swallow the message silently.
-  if (!peerOwner && coordRoot && !isAddressableName(coordRoot, name)) {
-    const suggestions = suggestNames(coordRoot, name);
-    emit.error({
-      code: "unknown_agent",
-      message:
-        `no agent has ever been named "${name}". ` +
-        (suggestions.length > 0 ? `Did you mean ${suggestions.join(", ")}? ` : "") +
-        `Run \`${resolveBinName()} agents list\` for live sessions.`,
-    });
-    process.exit(1);
-  }
-
+  const coordRoot = monorepoRoot() ?? process.cwd();
   const myHb = readCurrentCoordinationRow(myOwner);
   const fromName = myHb?.name ?? "anonymous";
-  const body = `from agent-${fromName}: ${message.trim()}`;
-
-  // A live recipient gets the journal entry immediately, so a peer reading
-  // their own journal mid-session sees it without waiting for a prompt. A
-  // dormant recipient has no journal to write to yet; the drain writes it into
-  // whichever session picks the message up.
-  const doc = peerOwner ? appendEntry(peerOwner, "handoff", body) : null;
-
-  let queued: QueueResult;
+  let sent: ReturnType<typeof sendPeerMessage>;
   try {
-    queued = queueMailboxMessage({
-      coordRoot: coordRoot ?? process.cwd(),
-      toName: name,
-      fromName,
-      fromInstanceId: myOwner,
+    sent = sendPeerMessage({
+      coordRoot,
+      target: { name, instanceId: opts.instanceId, requireLive: opts.requireLive },
+      senderName: fromName,
+      senderInstanceId: myOwner,
       body: message.trim(),
-      journaled: Boolean(peerOwner),
     });
   } catch (error) {
-    if (error instanceof MailboxCapacityError) {
-      emit.error({ code: `mailbox_${error.reason_code}`, message: error.message });
+    if (error instanceof HarneryInboxCapacityError) {
+      emit.error({ code: `inbox_${error.reason_code}`, message: error.message });
       process.exit(1);
     }
     throw error;
   }
+  if (!sent.ok) {
+    emit.error({
+      code: sent.code,
+      message: sent.message,
+      ...(sent.candidates ? { candidates: sent.candidates } : {}),
+    });
+    process.exit(1);
+  }
 
   // Canonical delivery record: sender is the envelope owner, recipient rides
   // in data, so read-only observers can render the communication without
@@ -4862,21 +4941,20 @@ function runPing(name: string, message: string, opts: { json?: boolean }): void
     observation: {
       event_type: "coord.message_observed",
       direction: "sent",
-      subject: peerOwner ?? `name:${queued.message.to_name}`,
+      subject: sent.target.instance_id,
+      message_id: sent.message_id,
       body: message.trim(),
     },
   });
 
   const data = {
-    peer: queued.message.to_name,
-    peer_instance_id: peerOwner,
-    delivery: peerOwner ? ("live" as const) : ("queued" as const),
-    message_id: queued.message.message_id,
-    pending: queued.pending,
+    peer: sent.target.name,
+    peer_instance_id: sent.target.instance_id,
+    state: sent.state,
+    message_id: sent.message_id,
+    synced: sent.synced,
+    body_bytes: sent.body_bytes,
     from: fromName,
-    body,
-    journal_path: doc?.path ?? null,
-    journal_bytes: doc?.bytes ?? null,
   };
 
   if (opts.json) {
@@ -4886,9 +4964,8 @@ function runPing(name: string, message: string, opts: { json?: boolean }): void
   }
   emit.data(data);
   emit.text(
-    peerOwner
-      ? `delivered to agent-${data.peer} (live; they see it on their next prompt): "${truncate(message.trim(), 80)}"\n`
-      : `queued for agent-${data.peer} (no live session; delivered when a session of that name next starts): "${truncate(message.trim(), 80)}"\n`,
+    `${data.state} for agent-${data.peer} (${data.peer_instance_id}); ` +
+      `stored as ${data.message_id}, pending until surfaced to that task.\n`,
   );
 }
 

package/src/commands/browse.ts

@@ -134,6 +134,7 @@ import {
 import {
   harvestDomain,
   harvestWindowsChromeCookies,
+  keepWindowsChromeSession,
   stopWindowsChromeProfile,
   windowsChromePath,
   windowsLocalAppData,
@@ -3465,15 +3466,18 @@ function useWindowsPlainLogin(): boolean {
 
 /**
  * The WSL form of `--login`: the person signs in through the Windows
- * Chrome on a dedicated Windows profile with nothing attached. When the window
- * closes, the profile's cookies for the sign-in site are read and merged into
- * the shared cookie store, which later `browse` runs attach.
+ * Chrome on a dedicated Windows profile with nothing attached. Before the
+ * window opens, the profile is set to continue where it left off, so Chrome
+ * keeps browser-session cookies when the window closes. When the window
+ * closes, the profile's cookies for the sign-in site are read and merged
+ * into the shared cookie store, which later `browse` runs attach, and the
+ * last page open on that site is reported so an agent can resume from it.
  */
 async function runWindowsPlainLogin(
   url: string,
   storePath: string,
   loginCloseFile: string | null,
-  emit: { log: (message: string, level: "info" | "warn" | "error" | "debug") => void },
+  emit: Pick<EmitContext, "log" | "data">,
 ): Promise<void> {
   const chromeLinux = windowsChromePath();
   const localAppData = windowsLocalAppData();
@@ -3484,6 +3488,13 @@ async function runWindowsPlainLogin(
   }
   const chromeWindows = wslPathToWindows(chromeLinux);
   const profileWindows = windowsPlainProfile(localAppData);
+  const keep = keepWindowsChromeSession({ chromeWindows, profileWindows });
+  if (!keep.kept) {
+    emit.log(
+      "[--login] Could not set the sign-in profile to keep browser-session cookies. A sign-in that relies on them survives only if you end it from the terminal instead of closing the window.",
+      "warn",
+    );
+  }
   const child = spawn(
     chromeLinux,
     [`--user-data-dir=${profileWindows}`, "--no-first-run", "--no-default-browser-check", url],
@@ -3507,24 +3518,49 @@ async function runWindowsPlainLogin(
   );
   await Promise.race(waits);
   lifecycleAbort.abort();
-  stopWindowsChromeProfile(profileWindows);
+  const stop = stopWindowsChromeProfile(profileWindows);
+  if (stop.forced > 0) {
+    emit.log(
+      "[--login] Chrome did not close when asked and was stopped. Cookies set in its last 30 seconds may be missing; run the sign-in again if later pages are signed out.",
+      "warn",
+    );
+  }
   await Promise.race([exited, new Promise((r) => setTimeout(r, 5000))]);
   const domain = harvestDomain(url);
-  const cookies = harvestWindowsChromeCookies({ chromeWindows, profileWindows, domain });
+  const { cookies, pages } = harvestWindowsChromeCookies({ chromeWindows, profileWindows, domain });
+  const lastPage = pages[0] ?? null;
+  const names = [...new Set(cookies.map((cookie) => cookie.name))].sort();
+  const sessionCookies = cookies.filter((cookie) => cookie.expires <= 0).length;
   if (cookies.length === 0) {
     emit.log(
       `[--login] No ${domain} cookies were found in the Windows profile; the sign-in may not have completed.`,
       "warn",
     );
-    return;
+  } else {
+    const jar = new CookieJar({ path: storePath, source: "harn-browse" });
+    jar.save(mergeCookies(jar.load(), cookies));
+    emit.log(
+      `[--login] Copied ${cookies.length} ${domain} cookies (${sessionCookies} browser-session) into ${storePath}: ${names.join(", ")}.`,
+      "info",
+    );
   }
-  const jar = new CookieJar({ path: storePath, source: "harn-browse" });
-  jar.save(mergeCookies(jar.load(), cookies));
-  const names = [...new Set(cookies.map((cookie) => cookie.name))].sort().join(", ");
-  emit.log(
-    `[--login] Copied ${cookies.length} ${domain} cookies into ${storePath}: ${names}.`,
-    "info",
-  );
+  if (lastPage) {
+    emit.log(
+      `[--login] Last page: ${lastPage} (the last page you had open on ${domain}; open it to continue where the sign-in left off, since its address may carry a sign-in token that cookies alone do not replace).`,
+      "info",
+    );
+  }
+  emit.data({
+    login: {
+      domain,
+      store: storePath,
+      cookies: cookies.length,
+      sessionCookies,
+      names,
+      lastPage,
+      pages,
+    },
+  });
 }
 
 async function waitForLoginCloseFile(path: string, signal?: AbortSignal): Promise<void> {

package/src/commands/diagnostics.ts

@@ -50,6 +50,7 @@ export function registerDiagnosticsCommand(
           findings,
           bundles,
           capability,
+          supervisor: readSupervisorStatus(repoRoot),
           total_findings: findings.length,
           total_bundles: bundles.length,
         });
@@ -68,6 +69,7 @@ export function registerDiagnosticsCommand(
             schema_version: DIAGNOSTIC_COMMAND_SCHEMA_VERSION,
             kind: "diagnostic_finding",
             finding,
+            supervisor: readSupervisorStatus(repoRoot),
             timeline:
               readSupervisorTimeline(repoRoot, finding.id) ?? buildSupervisorTimeline(finding),
             explanation:
@@ -118,6 +120,7 @@ export function registerDiagnosticsCommand(
           schema_version: DIAGNOSTIC_COMMAND_SCHEMA_VERSION,
           kind: "diagnostic_advice",
           source: { mode: "live" },
+          supervisor: readSupervisorStatus(repoRoot),
           advice: buildDiagnosticAdvice({
             assessment: published.assessment,
             priorHysteresis: published.prior_hysteresis,
@@ -204,6 +207,13 @@ function liveFindingsCapability(repoRoot: string, reportPresent: boolean): Super
   }
   const status = readSupervisorStatus(repoRoot);
   if (status.running) return { source_kind: "supervisor.findings", state: "supported" };
+  if (status.liveness === "unknown")
+    return {
+      source_kind: "supervisor.findings",
+      state: "error",
+      reason_code: "supervisor_generation_unknown",
+      detail: status.build_status,
+    };
   return {
     source_kind: "supervisor.findings",
     state: "expired",

package/src/commands/doctor.ts

@@ -421,15 +421,34 @@ function checkWorkflowAdapter(adapter: AdapterName): { check: Check; installed:
 }
 
 function checkNode(): Check {
-  const v = process.versions.node;
+  return nodeCheck(whichVersion("node"), process.versions);
+}
+
+/**
+ * Report the `node` on PATH, which is what Node-based tools run. Under Bun,
+ * `process.versions.node` is the Node version Bun emulates, not an installed
+ * Node, so it is used only when doctor itself runs on Node and PATH has none.
+ */
+export function nodeCheck(
+  onPath: { ok: boolean; out: string },
+  runtime: { node: string; bun?: string },
+): Check {
+  const hint = "https://nodejs.org/en/download";
+  let v = onPath.ok ? onPath.out.replace(/^v/, "") : "";
+  if (!v) {
+    if (runtime.bun) {
+      return {
+        name: "node",
+        severity: "warn",
+        detail: "not on PATH (Bun runs harnery; Node-based tools need it)",
+        hint,
+      };
+    }
+    v = runtime.node;
+  }
   const major = Number.parseInt(v.split(".")[0], 10);
   if (Number.isNaN(major) || major < 20) {
-    return {
-      name: "node",
-      severity: "fail",
-      detail: `${v} (need ≥ 20)`,
-      hint: "https://nodejs.org/en/download",
-    };
+    return { name: "node", severity: "fail", detail: `${v} (need ≥ 20)`, hint };
   }
   return { name: "node", severity: "ok", detail: v };
 }

package/src/commands/governor.ts

@@ -385,12 +385,13 @@ function registerServiceCommand(
     .action(async (opts: { json?: boolean }) => {
       await withGovernorRootAsync(emit, async (coordRoot) => {
         let status = requestGovernorServiceStop(coordRoot);
+        const signal = { signal_sent: status.signal_sent, signal_verdict: status.signal_verdict };
         const deadline = Date.now() + 5_000;
         while (status.running && Date.now() < deadline) {
           await delay(50);
           status = readGovernorServiceStatus(coordRoot);
         }
-        emitServiceStatus(status, opts.json, emit);
+        emitServiceStatus({ ...status, ...signal }, opts.json, emit);
       });
     });
 
@@ -534,19 +535,31 @@ function emitServiceStatus(
     emit.data(status);
     return;
   }
-  if (!status.config && !status.record) {
-    emit.text("governor service: unconfigured\n");
-    return;
-  }
-  const state = status.running
-    ? (status.record?.state ?? "running")
-    : status.stale
-      ? "stale"
-      : "stopped";
+  const state =
+    status.liveness === "unknown"
+      ? "unknown"
+      : !status.config && !status.record
+        ? "unconfigured"
+        : status.running
+          ? (status.record?.state ?? "running")
+          : status.stale
+            ? "stale"
+            : "stopped";
   const lines = [
     `governor service: ${state}`,
+    `generation: ${status.generation}`,
+    `liveness: ${status.liveness}`,
+    `running build: ${status.running_build ? `${status.running_build.version} (${status.running_build.revision})` : "unknown"}`,
+    `installed build: ${status.installed_build.version} (${status.installed_build.revision})`,
+    `build: ${status.build_status}`,
     `goals: ${status.config?.goal_ids.join(", ") || "none"}`,
   ];
+  if (status.signal_sent !== undefined) {
+    lines.push(`signal sent: ${status.signal_sent ? "yes" : "no"} (${status.signal_verdict})`);
+    if (!status.signal_sent && status.record?.state !== "stopped") {
+      lines.push("The durable stop request remains for the service to read.");
+    }
+  }
   if (status.record) {
     lines.push(`pid: ${status.record.pid} on ${status.record.host}`);
     lines.push(`heartbeat: ${status.record.heartbeat_at}`);