agent-relay-server 0.23.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",
@@ -33,7 +33,7 @@
     "CONTRIBUTING.md"
   ],
   "dependencies": {
-    "agent-relay-sdk": "0.2.13"
+    "agent-relay-sdk": "0.2.14"
   },
   "scripts": {
     "prepack": "bun run build:dashboard:bundle >&2",

package/public/index.html

@@ -10168,6 +10168,8 @@ function parseSseFrame(frame) {
 }
 //#endregion
 //#region src/lib/api.ts
+var API_TIMEOUT_MS = 2e4;
+var SSE_STALE_MS = 35e3;
 var authToken = "";
 function setAuthToken(token) {
 	authToken = token;
@@ -10211,11 +10213,11 @@ function openTerminalWebSocket(orchestratorId, session) {
 	return new WebSocket(url);
 }
 function openRelayEventStream(token, handlers) {
-	const abort = new AbortController();
 	const eventUrl = new URL("api/events", baseUrl()).toString();
 	let closed = false;
 	let retryMs = 5e3;
 	let reconnectTimer = null;
+	let activeAbort = null;
 	const scheduleReconnect = () => {
 		if (closed) return;
 		reconnectTimer = setTimeout(connect, retryMs);
@@ -10226,6 +10228,11 @@ function openRelayEventStream(token, handlers) {
 		if (data.length > 0) handlers.message(event, data.join("\n"));
 	};
 	const connect = async () => {
+		if (closed) return;
+		const ac = new AbortController();
+		activeAbort = ac;
+		let lastFrameAt = Date.now();
+		let staleTimer = null;
 		try {
 			const headers = { Accept: "text/event-stream" };
 			const effectiveToken = token || getAuthToken();
@@ -10233,10 +10240,14 @@ function openRelayEventStream(token, handlers) {
 			const response = await fetch(eventUrl, {
 				headers,
 				cache: "no-store",
-				signal: abort.signal
+				signal: ac.signal
 			});
 			if (!response.ok || !response.body) throw new Error(`SSE failed: ${response.status}`);
 			handlers.connected?.();
+			lastFrameAt = Date.now();
+			staleTimer = setInterval(() => {
+				if (Date.now() - lastFrameAt > SSE_STALE_MS) ac.abort();
+			}, 5e3);
 			const reader = response.body.getReader();
 			const decoder = new TextDecoder();
 			let buffer = "";
@@ -10246,6 +10257,7 @@ function openRelayEventStream(token, handlers) {
 					buffer += decoder.decode();
 					break;
 				}
+				lastFrameAt = Date.now();
 				buffer += decoder.decode(value, { stream: true });
 				let frameEnd = buffer.indexOf("\n\n");
 				while (frameEnd >= 0) {
@@ -10256,6 +10268,7 @@ function openRelayEventStream(token, handlers) {
 				}
 			}
 		} catch {} finally {
+			if (staleTimer) clearInterval(staleTimer);
 			if (closed) return;
 			handlers.disconnected?.();
 			scheduleReconnect();
@@ -10265,13 +10278,14 @@ function openRelayEventStream(token, handlers) {
 	return { close() {
 		closed = true;
 		if (reconnectTimer) clearTimeout(reconnectTimer);
-		abort.abort();
+		activeAbort?.abort();
 	} };
 }
 async function api(method, path, body) {
 	const opts = {
 		method,
-		headers: {}
+		headers: {},
+		signal: AbortSignal.timeout(API_TIMEOUT_MS)
 	};
 	const headers = opts.headers;
 	if (authToken) headers["X-Agent-Relay-Token"] = authToken;
@@ -11391,6 +11405,14 @@ function agentPresence(now, agent, attention, pair) {
 		reconnecting: false,
 		badges
 	};
+	if (lifecycleAction.startsWith("finalizing-")) return {
+		label: `wrapping up (${lifecycleAction.slice(11)})`,
+		tone: "warning",
+		icon: "Hourglass",
+		stale,
+		reconnecting,
+		badges
+	};
 	if (lifecycleAction === "shutting-down") return {
 		label: "shutting down",
 		tone: "warning",
@@ -11764,6 +11786,7 @@ function toneToColor(tone) {
 function statusDotColor(agent, now) {
 	if (!agent) return "bg-zinc-500 opacity-50";
 	if (agent.status === "offline") return "bg-zinc-500 opacity-50";
+	if (typeof agent.meta?.lifecycleAction === "string" && agent.meta.lifecycleAction.startsWith("finalizing-")) return "bg-amber-500 animate-pulse";
 	if (agent.meta?.lifecycleAction === "shutting-down" || agent.meta?.lifecycleAction === "restarting") return "bg-yellow-500 animate-pulse";
 	if (agent.meta?.lifecycleAction === "killing") return "bg-red-500 animate-pulse";
 	if (providerBlockedState(agent)) return "bg-red-500 animate-pulse";
@@ -12982,10 +13005,13 @@ var useRelayStore = create$1()(persist((set, get) => ({
 	connectSSE() {
 		get().disconnectSSE();
 		set({ _es: openRelayEventStream(get().authToken, {
-			connected: () => set(get().connectionError ? {
-				connected: true,
-				connectionError: false
-			} : { connected: true }),
+			connected: () => {
+				set(get().connectionError ? {
+					connected: true,
+					connectionError: false
+				} : { connected: true });
+				get().refreshLiveData();
+			},
 			disconnected: () => set({ connected: false }),
 			message: (event, data) => {
 				if (event === "connected") return;
@@ -77597,6 +77623,49 @@ function OverviewView() {
 	});
 }
 //#endregion
+//#region src/hooks/use-agent-terminal.ts
+/**
+* Open/close lifecycle for an agent's terminal session. Shared by the agent
+* card and the chat header — both POST a terminal-session, track the target,
+* and DELETE guest sessions on close. Pass null/undefined to no-op (e.g. when
+* no agent is selected).
+*/
+function useAgentTerminal(agentId) {
+	const showError = useRelayStore((s) => s.showError);
+	const [terminalOpen, setTerminalOpen] = (0, import_react.useState)(false);
+	const [terminalTarget, setTerminalTarget] = (0, import_react.useState)(null);
+	const [terminalOpening, setTerminalOpening] = (0, import_react.useState)(false);
+	async function openTerminal() {
+		if (!agentId || terminalOpening) return;
+		setTerminalOpening(true);
+		try {
+			setTerminalTarget(await api("POST", "/agents/" + encodeURIComponent(agentId) + "/terminal-session"));
+			setTerminalOpen(true);
+		} catch (e) {
+			showError("Terminal Failed", e.message);
+		} finally {
+			setTerminalOpening(false);
+		}
+	}
+	function closeTerminal(open) {
+		if (open) {
+			setTerminalOpen(true);
+			return;
+		}
+		setTerminalOpen(false);
+		const target = terminalTarget;
+		setTerminalTarget(null);
+		if (agentId && target?.mode === "guest") api("DELETE", "/agents/" + encodeURIComponent(agentId) + "/terminal-session/" + encodeURIComponent(target.session)).catch(() => {});
+	}
+	return {
+		terminalOpen,
+		terminalTarget,
+		terminalOpening,
+		openTerminal,
+		closeTerminal
+	};
+}
+//#endregion
 //#region node_modules/comma-separated-tokens/index.js
 /**
 * Serialize an array of strings or numbers to comma-separated tokens.
@@ -127279,9 +127348,6 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 	const pendingAttachmentsRef = (0, import_react.useRef)([]);
 	const [pendingAttachments, setPendingAttachments] = (0, import_react.useState)([]);
 	const [dragActive, setDragActive] = (0, import_react.useState)(false);
-	const [terminalOpen, setTerminalOpen] = (0, import_react.useState)(false);
-	const [terminalTarget, setTerminalTarget] = (0, import_react.useState)(null);
-	const [terminalOpening, setTerminalOpening] = (0, import_react.useState)(false);
 	const [filePreview, setFilePreview] = (0, import_react.useState)(null);
 	const [floatingPreview, setFloatingPreview] = (0, import_react.useState)(null);
 	const [filePreviewError, setFilePreviewError] = (0, import_react.useState)("");
@@ -127302,6 +127368,8 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 		selectedInboxThread
 	]);
 	const agent = agentsById[selectedInboxThread] || null;
+	const agentFinalizing = typeof agent?.meta?.lifecycleAction === "string" && agent.meta.lifecycleAction.startsWith("finalizing-");
+	const { terminalOpen, terminalTarget, terminalOpening, openTerminal: handleOpenTerminal, closeTerminal: handleCloseTerminal } = useAgentTerminal(agent?.id);
 	const agentSpawnRequestId = typeof agent?.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : "";
 	const importedHistory = (0, import_react.useMemo)(() => {
 		return chatHistoryImports.filter((history) => history.targetAgentId === selectedInboxThread || Boolean(agentSpawnRequestId && history.targetSpawnRequestId === agentSpawnRequestId));
@@ -127382,18 +127450,6 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 		agent?.createdAt,
 		importedHistory
 	]);
-	async function handleOpenTerminal() {
-		if (!agent || terminalOpening) return;
-		setTerminalOpening(true);
-		try {
-			setTerminalTarget(await api("POST", "/agents/" + encodeURIComponent(agent.id) + "/terminal-session"));
-			setTerminalOpen(true);
-		} catch (e) {
-			showError("Terminal Failed", e.message);
-		} finally {
-			setTerminalOpening(false);
-		}
-	}
 	const clearFilePreviewCloseTimer = (0, import_react.useCallback)(() => {
 		if (filePreviewCloseTimer.current === null) return;
 		window.clearTimeout(filePreviewCloseTimer.current);
@@ -127475,16 +127531,6 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 		setFilePreview(null);
 		setFilePreviewError("");
 	}
-	function handleCloseTerminal(open) {
-		if (open) {
-			setTerminalOpen(true);
-			return;
-		}
-		setTerminalOpen(false);
-		const target = terminalTarget;
-		setTerminalTarget(null);
-		if (agent && target?.mode === "guest") api("DELETE", "/agents/" + encodeURIComponent(agent.id) + "/terminal-session/" + encodeURIComponent(target.session)).catch(() => {});
-	}
 	async function uploadFiles(files) {
 		const list = Array.from(files).filter((file) => file.size > 0);
 		if (!list.length) return;
@@ -127530,7 +127576,7 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 		setPendingAttachments([]);
 	}
 	function handleSend() {
-		if (!draft.trim() && readyAttachments.length === 0 || !selectedInboxThread || chatSending || hasPendingUploads) return;
+		if (!draft.trim() && readyAttachments.length === 0 || !selectedInboxThread || chatSending || hasPendingUploads || agentFinalizing) return;
 		const attachments = readyAttachments.map((item) => ({
 			artifactId: item.artifact.id,
 			kind: item.artifact.kind,
@@ -127988,7 +128034,7 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 									}),
 									/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button, {
 										size: "icon",
-										disabled: !draft.trim() && readyAttachments.length === 0 || hasPendingUploads || chatSending,
+										disabled: !draft.trim() && readyAttachments.length === 0 || hasPendingUploads || chatSending || agentFinalizing,
 										onClick: handleSend,
 										className: "shrink-0 mb-0.5 rounded-xl h-[42px] w-[42px]",
 										children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Send, { className: "w-4 h-4" })
@@ -128038,7 +128084,7 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 										})]
 									}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button, {
 										size: "icon",
-										disabled: !draft.trim() && readyAttachments.length === 0 || hasPendingUploads || chatSending,
+										disabled: !draft.trim() && readyAttachments.length === 0 || hasPendingUploads || chatSending || agentFinalizing,
 										onClick: handleSend,
 										className: "rounded-xl h-9 w-9",
 										children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Send, { className: "w-4 h-4" })
@@ -128047,7 +128093,7 @@ function ChatPanel({ threads, onBack, showBackButton }) {
 							}),
 							/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
 								className: "text-xs text-muted-foreground mt-1.5 hidden md:block",
-								children: "Enter to send · Shift+Enter for newline"
+								children: agentFinalizing ? `${agent ? displayName(agent) : "Agent"} is wrapping up (${(agent?.meta?.lifecycleAction).slice(11)}) — messaging paused` : "Enter to send · Shift+Enter for newline"
 							})
 						]
 					})
@@ -128176,13 +128222,10 @@ function AgentCard({ agent }) {
 	const openPairInvite = useRelayStore((s) => s.openPairInvite);
 	const openRename = useRelayStore((s) => s.openRename);
 	const openConfirm = useRelayStore((s) => s.openConfirm);
-	const showError = useRelayStore((s) => s.showError);
 	const doAgentAction = useRelayStore((s) => s.doAgentAction);
 	const doDeleteAgent = useRelayStore((s) => s.doDeleteAgent);
 	const openFilesForAgent = useRelayStore((s) => s.openFilesForAgent);
-	const [terminalOpen, setTerminalOpen] = (0, import_react.useState)(false);
-	const [terminalTarget, setTerminalTarget] = (0, import_react.useState)(null);
-	const [terminalOpening, setTerminalOpening] = (0, import_react.useState)(false);
+	const { terminalOpen, terminalTarget, terminalOpening, openTerminal: handleOpenTerminal, closeTerminal: handleCloseTerminal } = useAgentTerminal(agent.id);
 	const pairsMap = usePairsByAgentId();
 	const rawAttention = useAgentAttention(agent);
 	const pair = pairsMap[agent.id] || null;
@@ -128196,28 +128239,6 @@ function AgentCard({ agent }) {
 	const canOpenTerminal = Boolean(agent.providerCapabilities?.terminal?.live?.read || agent.providerCapabilities?.terminal?.attach?.create);
 	const canWriteTerminal = Boolean(agent.providerCapabilities?.terminal?.live?.write || agent.providerCapabilities?.model?.provider === "claude");
 	const canForget = agentCanBeForgotten(agent);
-	async function handleOpenTerminal() {
-		if (terminalOpening) return;
-		setTerminalOpening(true);
-		try {
-			setTerminalTarget(await api("POST", "/agents/" + encodeURIComponent(agent.id) + "/terminal-session"));
-			setTerminalOpen(true);
-		} catch (e) {
-			showError("Terminal Failed", e.message);
-		} finally {
-			setTerminalOpening(false);
-		}
-	}
-	function handleCloseTerminal(open) {
-		if (open) {
-			setTerminalOpen(true);
-			return;
-		}
-		setTerminalOpen(false);
-		const target = terminalTarget;
-		setTerminalTarget(null);
-		if (target?.mode === "guest") api("DELETE", "/agents/" + encodeURIComponent(agent.id) + "/terminal-session/" + encodeURIComponent(target.session)).catch(() => {});
-	}
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Card, {
 		className: "group hover:border-zinc-600 transition-colors cursor-pointer",
 		onClick: () => openAgentDetail(agent),

package/runner/src/adapter.ts

@@ -1,5 +1,6 @@
 import type { AgentProfile, Message } from "agent-relay-sdk";
 import { isRecord } from "agent-relay-sdk";
+import type { SessionEvent } from "./session-insights";
 
 export type SemanticStatus = "idle" | "busy" | "offline" | "error";
 type ProviderWorkKind = "provider-turn" | "subagent";
@@ -133,6 +134,15 @@ export interface ProviderAdapter {
   shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void>;
   compact?(process: ManagedProcess): Promise<Record<string, unknown> | void>;
   clearContext?(process: ManagedProcess): Promise<Record<string, unknown> | void>;
+  // Normalize the session so far into the provider-agnostic SessionEvent stream the
+  // Insights context-ratio signal (#183/#184) reduces. Called by the runner's
+  // pre-session-destroy seam before any compact/clear/restart/shutdown. The runner owns
+  // the per-segment cursor (it slices events since the last capture), so this returns the
+  // full ordered event list for the current process lifetime. `ctx.transcriptPath` is
+  // supplied for transcript-backed providers (Claude); event-stream providers (Codex)
+  // ignore it and return their accumulated log. Return null when there is nothing to
+  // measure. Best-effort: may be omitted by providers without a session view yet.
+  collectSessionEvents?(process: ManagedProcess, ctx: { transcriptPath?: string }): Promise<SessionEvent[] | null>;
   // Interrupt the in-flight turn without ending the session (ESC for Claude's
   // tmux pane, turn/interrupt for the Codex app-server). Provider-independent at
   // the runner boundary; each adapter does what its provider actually supports.

package/src/branch-landed.ts

@@ -0,0 +1,77 @@
+import { emitRelayEvent } from "./events";
+import { getNotificationsConfig } from "./config-store";
+import { notifySystemMessage } from "./notify";
+import type { WorkspaceRecord } from "./types";
+
+export interface BranchLandedInput {
+  /**
+   * The workspace as it was AT land time — `branch` must be the branch that landed,
+   * captured before any land-and-continue recycle repoints the row (#206). `ownerAgentId`
+   * is the author the "landed" notice is pushed to.
+   */
+  workspace: Pick<WorkspaceRecord, "id" | "repoRoot" | "branch" | "baseRef" | "ownerAgentId">;
+  /** SHA the base now points at after the land. */
+  mergedSha?: string;
+  /** Subject line of the landed commit, when the orchestrator reported it. */
+  subject?: string;
+  /** Fresh branch the worktree was recycled onto (land-and-continue), if any. */
+  newBranch?: string;
+}
+
+/**
+ * #239 — turn an authoritative land completion into a relay-driven push so the author
+ * stops polling to learn it merged. Always emits the durable `branch.landed` event (the
+ * rest of the bus does the same); only the agent-facing push is gated, since it wakes the
+ * recipient. Offline authors get it on next poll via store-ahead (#234).
+ *
+ * Agents-on-main fan-out (the second #239 recipient class) lands in a follow-up commit.
+ */
+export function notifyBranchLanded(input: BranchLandedInput): void {
+  const { workspace } = input;
+  const base = workspace.baseRef ?? "base";
+  const landedBranch = workspace.branch;
+  const shortSha = input.mergedSha ? input.mergedSha.slice(0, 12) : undefined;
+
+  emitRelayEvent({
+    type: "branch.landed",
+    source: "server",
+    subject: workspace.id,
+    data: {
+      workspaceId: workspace.id,
+      repoRoot: workspace.repoRoot,
+      branch: landedBranch,
+      base,
+      sha: input.mergedSha,
+      subject: input.subject,
+      author: workspace.ownerAgentId,
+      newBranch: input.newBranch,
+    },
+  });
+
+  const config = getNotificationsConfig();
+  if (!config.enabled || !config.branchLanded) return;
+
+  const author = workspace.ownerAgentId;
+  if (!author) return;
+
+  const branchLabel = landedBranch ? `\`${landedBranch}\`` : "Your branch";
+  const shaLabel = shortSha ? ` as \`${shortSha}\`` : "";
+  const subjectLabel = input.subject ? ` — "${input.subject}"` : "";
+  const continueLabel = input.newBranch
+    ? ` You're now on \`${input.newBranch}\` — keep working there.`
+    : " Worktree reclaimed.";
+
+  notifySystemMessage(author, {
+    subject: "Your branch landed",
+    body: `✅ ${branchLabel} landed on \`${base}\`${shaLabel}${subjectLabel}.${continueLabel}`,
+    payload: {
+      kind: "branch.landed",
+      workspaceId: workspace.id,
+      repoRoot: workspace.repoRoot,
+      branch: landedBranch,
+      base,
+      sha: input.mergedSha,
+      newBranch: input.newBranch,
+    },
+  });
+}

package/src/config-store.ts

@@ -10,6 +10,7 @@ import type {
   InsightsConfig,
   ManagedAgentState,
   ManagedAgentStatus,
+  NotificationsConfig,
   SpawnApprovalMode,
   SpawnPolicy,
   SpawnProvider,
@@ -24,6 +25,8 @@ const STEWARD_NAMESPACE = "steward";
 const STEWARD_KEY = "default";
 const INSIGHTS_NAMESPACE = "insights";
 const INSIGHTS_KEY = "default";
+const NOTIFICATIONS_NAMESPACE = "notifications";
+const NOTIFICATIONS_KEY = "default";
 const WORKSPACE_NAMESPACE = "workspace";
 const WORKSPACE_KEY = "default";
 const VALID_PROFILE_PROVIDERS = ["any", "claude", "codex"] as const;
@@ -460,6 +463,26 @@ function validateInsightsConfig(value: unknown): InsightsConfig {
   };
 }
 
+// Relay-driven lifecycle push notifications (#239 event bus). Default-on; the
+// operator can flip the master switch or individual events off via the generic
+// config route. Push messages wake recipients, so they must be suppressible.
+const NOTIFICATIONS_CONFIG_DEFAULTS: NotificationsConfig = {
+  enabled: true,
+  branchLanded: true,
+};
+
+function validateNotificationsConfig(value: unknown): NotificationsConfig {
+  if (!isRecord(value)) throw new ValidationError("notifications config value must be an object");
+  return {
+    enabled: value.enabled === undefined
+      ? NOTIFICATIONS_CONFIG_DEFAULTS.enabled
+      : cleanBoolean(value.enabled, "enabled"),
+    branchLanded: value.branchLanded === undefined
+      ? NOTIFICATIONS_CONFIG_DEFAULTS.branchLanded
+      : cleanBoolean(value.branchLanded, "branchLanded"),
+  };
+}
+
 // Global workspace provisioning config for isolated worktrees (#159 follow-up).
 // Defaults seed the two untracked paths an isolated agent almost always needs:
 // the agent guide and the rig config, both gitignored so a fresh worktree lacks them.
@@ -487,6 +510,7 @@ function normalizeValue(namespace: string, key: string, value: unknown): unknown
   if (namespace === AGENT_PROFILE_NAMESPACE) return validateAgentProfile(key, value);
   if (namespace === STEWARD_NAMESPACE) return validateStewardConfig(value);
   if (namespace === INSIGHTS_NAMESPACE) return validateInsightsConfig(value);
+  if (namespace === NOTIFICATIONS_NAMESPACE) return validateNotificationsConfig(value);
   if (namespace === WORKSPACE_NAMESPACE) return validateWorkspaceConfig(value);
   if (JSON.stringify(value) === undefined) throw new ValidationError("value must be valid JSON");
   return value;
@@ -620,6 +644,13 @@ export function getInsightsConfigEntry(): ConfigEntry<InsightsConfig> {
   };
 }
 
+/** Lifecycle-notification config (#239), merged over defaults (always usable). */
+export function getNotificationsConfig(): NotificationsConfig {
+  const entry = getConfig<Partial<NotificationsConfig>>(NOTIFICATIONS_NAMESPACE, NOTIFICATIONS_KEY);
+  if (!entry) return { ...NOTIFICATIONS_CONFIG_DEFAULTS };
+  return validateNotificationsConfig({ ...NOTIFICATIONS_CONFIG_DEFAULTS, ...entry.value });
+}
+
 export function setInsightsConfig(value: unknown, updatedBy?: string): ConfigEntry<InsightsConfig> {
   return setConfig(INSIGHTS_NAMESPACE, INSIGHTS_KEY, value as InsightsConfig, updatedBy);
 }

package/src/connectors.ts

@@ -243,10 +243,46 @@ async function refreshConnectorStatus(id: string): Promise<void> {
 }
 
 export function startConnectorStatusPoller(): void {
-  void refreshAllConnectorStatuses();
+  // Relaunch connectors that were running before this process restarted (e.g. a
+  // deploy that took down the relay/orchestrator tree) BEFORE the first status
+  // poll overwrites their persisted "running" flag with the now-dead reality.
+  void reconcileConnectorsOnBoot().finally(() => void refreshAllConnectorStatuses());
   setInterval(() => void refreshAllConnectorStatuses(), STATUS_POLL_INTERVAL_MS);
 }
 
+// On boot, bring back any connector whose last persisted state says it was
+// running. `start` is idempotent — a daemon that survived the restart reports
+// "already running"; one that died with the process tree is relaunched. A
+// connector the operator deliberately stopped has running:false persisted, so
+// it stays down. Best-effort: failures are swallowed; the poll reflects truth.
+export async function reconcileConnectorsOnBoot(): Promise<void> {
+  for (const connector of listConnectors()) {
+    const wasRunning = connector.state?.running === true;
+    const canStart = Boolean(connector.manifest.commands.start?.length);
+    if (!wasRunning || !canStart) continue;
+    try {
+      await runConnectorAction(connector.id, "start");
+    } catch { /* boot relaunch is best-effort; status poll will surface failures */ }
+  }
+}
+
+// Flip a connector to running:false when the relay proves its advertised
+// endpoint is unreachable (e.g. the daemon died but state.json still claims
+// running:true). Stops the dashboard from lying until the 60s status poll runs.
+export function markConnectorUnreachable(id: string, detail: string): void {
+  const path = join(connectorDir(id), "state.json");
+  const current = readRecordFile(path);
+  if (!current || current.running === false) return;
+  const next = {
+    ...current,
+    status: "error",
+    detail,
+    running: false,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(path, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+}
+
 async function refreshAllConnectorStatuses(): Promise<void> {
   for (const connector of listConnectors()) {
     try {

package/src/lifecycle-manager.ts

@@ -268,6 +268,7 @@ export class LifecycleManager {
         graceful,
         timeoutMs: 10_000,
         reason,
+        orchestratorId: orch.id,
         requestedBy: "lifecycle-manager",
         requestedAt: this.now(),
       },

package/src/maintenance.ts

@@ -27,14 +27,13 @@ import {
   releaseExpiredMergeLeases,
   releaseOrphanedTasks,
   runDbMaintenance,
-  sendMessage,
   sweepArtifacts,
   updateWorkspaceStatus,
 } from "./db";
 import type { WorkspaceMergePreview, WorkspaceRecord, WorkspaceStatus } from "./types";
 import { requestWorkspaceMerge } from "./workspace-merge";
 import { workspaceActiveClaim } from "./workspace-claim";
-import { TERMINAL_WORKSPACE_STATUSES } from "./workspace-phase";
+import { READY_TO_LAND_STATUSES, TERMINAL_WORKSPACE_STATUSES } from "./workspace-phase";
 import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 import { getStewardConfig } from "./config-store";
 import { ensureRepoSteward } from "./steward";
@@ -46,11 +45,11 @@ import {
   emitAgentStatus,
   emitMessageClaimReleased,
   emitMessageExpired,
-  emitNewMessage,
   emitOrchestratorStatus,
   emitPoolBindingChanged,
   emitTaskChanged,
 } from "./sse";
+import { notifySystemMessage } from "./notify";
 import { pruneExpiredTokenRecords } from "./token-db";
 import type { Command, MaintenanceJob, MaintenanceJobRun } from "./types";
 
@@ -83,7 +82,10 @@ const STEWARD_WAKE_COOLDOWN_MS = Number(process.env.AGENT_RELAY_STEWARD_WAKE_COO
 const stewardEscalationMs = () => Number(process.env.AGENT_RELAY_WORKSPACE_STEWARD_ESCALATION_MS) || 60 * 60 * 1000;
 const stewardFallbackTarget = () => (process.env.AGENT_RELAY_WORKSPACE_STEWARD_FALLBACK || "").trim();
 // Statuses that need an owner — a stranded one of these is what escalation rescues.
-const STRANDABLE_STATUSES = new Set<WorkspaceStatus>(["review_requested", "conflict"]);
+// Derived from the shared ready-to-land set (#242) plus `conflict`, so a stranded
+// `ready` worktree (no online steward) escalates to the fallback target instead of
+// rotting silently — same gap that left the original #242 branch parked.
+const STRANDABLE_STATUSES = new Set<WorkspaceStatus>([...READY_TO_LAND_STATUSES, "conflict"]);
 // Live statuses worth scanning. Terminal (cleaned/merged/abandoned) and
 // in-flight (cleanup_requested) states are skipped.
 const CONFLICT_SCAN_STATUSES = new Set<WorkspaceStatus>(["active", "ready", "review_requested", "merge_planned", "conflict"]);
@@ -394,7 +396,7 @@ const definitions: MaintenanceJobDefinition[] = [
   {
     id: "workspace-auto-merge",
     title: "Workspace auto-merge",
-    description: "Auto-merge any non-conflicting review_requested worktree into base under the per-repo lease (rebasing when the base moved on); only real or unknown conflicts are left for the steward.",
+    description: "Auto-merge any non-conflicting ready/review_requested worktree into base under the per-repo lease (rebasing when the base moved on); only real or unknown conflicts are left for the steward.",
     intervalMs: WORKSPACE_AUTO_MERGE_INTERVAL_MS,
     runOnStart: false,
     timeoutMs: 60 * 1000,
@@ -532,15 +534,11 @@ function wakeRepoSteward(ws: WorkspaceRecord, reason: string): string | null {
   const policyName = ensureRepoSteward(ws.repoRoot);
   if (!policyName) return null;
   try {
-    const msg = sendMessage({
-      from: "system",
-      to: `policy:${policyName}`,
-      kind: "system",
+    notifySystemMessage(`policy:${policyName}`, {
       subject: `Steward: ${ws.status} workspace needs attention`,
       body: `Workspace \`${ws.branch ?? ws.id}\` (id ${ws.id}) in ${ws.repoRoot} is ${ws.status} and could not auto-land (${reason}). Claim it first so auto-merge yields: \`agent-relay workspace claim --id ${ws.id} --purpose steward\`. Inspect: \`agent-relay steward inspect ${ws.id}\`. Then cd into ${ws.worktreePath}, rebase onto ${ws.baseRef ?? "base"}, resolve, run checks, and land: \`agent-relay workspace land --id ${ws.id} --strategy rebase-ff\` — or \`agent-relay workspace release --id ${ws.id}\` and escalate if you can't.`,
       payload: { kind: "workspace.steward-task", workspaceId: ws.id, repoRoot: ws.repoRoot, worktreePath: ws.worktreePath, branch: ws.branch, baseRef: ws.baseRef, status: ws.status, reason },
     });
-    emitNewMessage(msg);
     getLifecycleManager().onMessageForPolicy(policyName);
     patchWorkspaceMetadata(ws.id, { stewardWokenAt: Date.now(), stewardPolicy: policyName });
     return policyName;
@@ -631,15 +629,11 @@ async function scanWorkspaceConflicts(): Promise<Record<string, unknown>> {
         if (woke) notifiedStewards.push(woke);
       } else if (ws.stewardAgentId) {
         try {
-          const msg = sendMessage({
-            from: "system",
-            to: ws.stewardAgentId,
-            kind: "system",
+          notifySystemMessage(ws.stewardAgentId, {
             subject: "Workspace merge conflict",
             body: `Workspace \`${ws.branch ?? ws.id}\` in ${ws.repoRoot} can no longer merge cleanly into ${p.baseRef ?? "base"} (${p.ahead ?? "?"} ahead, ${p.behind ?? "?"} behind). As repo steward, please coordinate resolution.`,
             payload: { kind: "workspace.conflict", workspaceId: ws.id, repoRoot: ws.repoRoot, branch: ws.branch, baseRef: p.baseRef, ahead: p.ahead, behind: p.behind },
           });
-          emitNewMessage(msg);
           notifiedStewards.push(ws.stewardAgentId);
         } catch {
           // Steward unregistered/stale — the activity event still records it.
@@ -657,9 +651,11 @@ async function scanWorkspaceConflicts(): Promise<Record<string, unknown>> {
   return { scanned: candidates.length, flagged, cleared, merged, notifiedStewards };
 }
 
-// Deterministic auto-land (Layer 0, issue #167 / #207). Walk the "ready to land"
-// queue (`review_requested` isolated worktrees) and land any whose merge is
-// predicted conflict-free, via the shared lease-serialized merge helper — even
+// Deterministic auto-land (Layer 0, issue #167 / #207 / #242). Walk the "ready to
+// land" queue (isolated worktrees in any READY_TO_LAND status — `ready` from
+// `relay_workspace_ready`, or `review_requested` from a failed-merge retry) and
+// land any whose merge is predicted conflict-free, via the shared lease-serialized
+// merge helper — even
 // when the base moved on (behind>0): mergeRebaseFf rebases onto the current base
 // before fast-forwarding. Only a predicted conflict or an unknown merge state is
 // left for the steward; clean parallel work lands with no agent in the loop.
@@ -669,7 +665,7 @@ async function autoMergeCleanFastForwards(): Promise<Record<string, unknown>> {
   if (!orchestrators.length) return { scanned: 0, skipped: "no online orchestrators" };
 
   const candidates = listWorkspaces().filter(
-    (ws) => ws.mode === "isolated" && Boolean(ws.worktreePath) && ws.status === "review_requested",
+    (ws) => ws.mode === "isolated" && Boolean(ws.worktreePath) && READY_TO_LAND_STATUSES.has(ws.status),
   );
   const stewardEnabled = getStewardConfig().enabled;
   const merged: string[] = [];
@@ -738,7 +734,7 @@ async function autoMergeCleanFastForwards(): Promise<Record<string, unknown>> {
 function notifyTarget(target: string, subject: string, body: string, payload: Record<string, unknown>): string | null {
   if (!target) return null;
   try {
-    emitNewMessage(sendMessage({ from: "system", to: target, kind: "system", subject, body, payload }));
+    notifySystemMessage(target, { subject, body, payload });
     return target;
   } catch {
     return null;

package/src/managed-policy.ts

@@ -32,6 +32,7 @@ export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string,
   const grant = spawnGrantForProfile(policy.profile);
   return buildSpawnCommand({
     provider: policy.provider,
+    orchestratorId: policy.orchestratorId,
     cwd: policy.cwd,
     workspaceMode: effectiveManagedPolicyWorkspaceMode(policy),
     rig: policy.rig || undefined,