agent-relay-server 0.120.5 → 0.121.0

package/src/services/send-message.ts

@@ -28,11 +28,13 @@ import {
   getMessage,
   listAgents,
   promoteLineageCapturedResponse,
+  sendMessagesBatchWithResult,
   sendMessageWithResult,
   channelObligationAnsweredBy,
+  type SendMessageResult as DbSendMessageResult,
 } from "../db";
 import { planSend, type DeliveryReceipt } from "../agent-ref";
-import { emitMessageQueued, emitNewMessage } from "../sse";
+import { emitMessageQueued, emitNewMessages } from "../sse";
 import { getLifecycleManager } from "../lifecycle-manager";
 import { isComponentAuthorizedFor, isIntegrationAllowed } from "../security";
 import { AmbiguousTargetError, ServiceAuthError } from "./errors";
@@ -175,6 +177,42 @@ export function sendMessageService(
   ctx: AuthContext,
   opts: SendMessageOptions = {},
 ): SendMessageResult {
+  const { receipt, suppressedParent } = prepareSendMessage(input, ctx, opts);
+  if (suppressedParent) return { message: suppressedParent, created: false, receipt };
+  const result = sendMessageWithResult(input);
+  emitSendResults([result]);
+  return { message: result.message, created: result.created, receipt };
+}
+
+export function sendMessagesBatchService(
+  inputs: SendMessageInput[],
+  ctx: AuthContext,
+  opts: SendMessageOptions = {},
+): SendMessageResult[] {
+  const prepared = inputs.map((input) => ({ input, ...prepareSendMessage(input, ctx, opts) }));
+  const results: SendMessageResult[] = [];
+  const storeInputs: SendMessageInput[] = [];
+  const storeIndexes: number[] = [];
+  for (const item of prepared) {
+    if (item.suppressedParent) {
+      results.push({ message: item.suppressedParent, created: false, receipt: item.receipt });
+      continue;
+    }
+    results.push(null as unknown as SendMessageResult);
+    storeIndexes.push(results.length - 1);
+    storeInputs.push(item.input);
+  }
+  const stored = sendMessagesBatchWithResult(storeInputs);
+  for (let i = 0; i < stored.length; i++) {
+    const result = stored[i]!;
+    const outputIndex = storeIndexes[i]!;
+    results[outputIndex] = { message: result.message, created: result.created, receipt: prepared[outputIndex]!.receipt };
+  }
+  emitSendResults(stored);
+  return results;
+}
+
+function prepareSendMessage(input: SendMessageInput, ctx: AuthContext, opts: SendMessageOptions): { receipt: DeliveryReceipt; suppressedParent: Message | null } {
   const receipt = validateSendMessageAuthorization(input, ctx, opts);
   // Reply-obligation linking: some real answers are ordinary sends without replyTo/thread linkage.
   // Channel bridge replies have a single unambiguous open obligation case;
@@ -184,29 +222,33 @@ export function sendMessageService(
     const answered = channelObligationAnsweredBy(input.from, input.to);
     if (answered !== null) input.replyTo = answered;
   }
-  const suppressedParent = suppressResultsOnlyAck(input);
-  if (suppressedParent) return { message: suppressedParent, created: false, receipt };
-  const result = sendMessageWithResult(input);
-  if (result.created) {
-    if (result.message.deliveryStatus === "queued") {
-      emitMessageQueued(result.message);
-      // Wake an on-demand managed policy that has no live agent attached yet.
-      if (result.message.to?.startsWith("policy:")) {
-        getLifecycleManager().onMessageForPolicy(result.message.to.slice("policy:".length));
+  return { receipt, suppressedParent: suppressResultsOnlyAck(input) };
+}
+
+function emitSendResults(results: DbSendMessageResult[]): void {
+  const liveMessages: Message[] = [];
+  for (const result of results) {
+    if (result.created) {
+      if (result.message.deliveryStatus === "queued") {
+        emitMessageQueued(result.message);
+        // Wake an on-demand managed policy that has no live agent attached yet.
+        if (result.message.to?.startsWith("policy:")) {
+          getLifecycleManager().onMessageForPolicy(result.message.to.slice("policy:".length));
+        }
+      } else {
+        liveMessages.push(result.message);
       }
-    } else {
-      emitNewMessage(result.message);
+      const promoted = promoteLineageCapturedResponse(result.message);
+      if (promoted?.created) liveMessages.push(promoted.message);
+    } else if (result.updated) {
+      // Session-step upsert (#parity): the row changed in place (same DB id). Re-emit so the
+      // dashboard's id-keyed merge replaces the existing step live — no duplicate row.
+      liveMessages.push(result.message);
+      const promoted = promoteLineageCapturedResponse(result.message);
+      if (promoted?.created) liveMessages.push(promoted.message);
     }
-    const promoted = promoteLineageCapturedResponse(result.message);
-    if (promoted?.created) emitNewMessage(promoted.message);
-  } else if (result.updated) {
-    // Session-step upsert (#parity): the row changed in place (same DB id). Re-emit so the
-    // dashboard's id-keyed merge replaces the existing step live — no duplicate row.
-    emitNewMessage(result.message);
-    const promoted = promoteLineageCapturedResponse(result.message);
-    if (promoted?.created) emitNewMessage(promoted.message);
   }
-  return { message: result.message, created: result.created, receipt };
+  emitNewMessages(liveMessages);
 }
 
 function suppressResultsOnlyAck(input: SendMessageInput): Message | null {

package/src/services/spawn-registration-watchdog.ts

@@ -20,12 +20,21 @@ interface SpawnCommandGroup {
   rows: SpawnCommandRow[];
 }
 
+interface SpawnCandidateRow {
+  spawn_request_id: string;
+  latest_updated_at: number;
+}
+
 interface SpawnRegistrationWatchdogResult extends Record<string, unknown> {
   failedSpawnCommandIds: string[];
   notifiedSpawnCommandIds: string[];
   silencedSpawnCommandIds: string[];
+  confirmedSpawnCommandIds: string[];
+  checkedSpawnGroups: number;
 }
 
+const MAX_SPAWN_GROUPS_PER_RUN = 25;
+
 export function reapUnregisteredSpawnCommands(
   now = Date.now(),
   deadlineMs = SPAWN_REGISTRATION_DEADLINE_MS,
@@ -33,20 +42,40 @@ export function reapUnregisteredSpawnCommands(
 ): SpawnRegistrationWatchdogResult {
   const cutoff = now - deadlineMs;
   const notifyCutoff = now - notifyMaxAgeMs;
-  const rows = getDb().query(`
-    SELECT id, params, correlation_id, updated_at
-    FROM commands
-    WHERE type = 'agent.spawn'
-      AND status = 'succeeded'
-    ORDER BY updated_at ASC
-  `).all() as SpawnCommandRow[];
+  const candidateRows = getDb().query(`
+    WITH spawn_groups AS (
+      SELECT
+        coalesce(nullif(json_extract(params, '$.spawnRequestId'), ''), correlation_id) AS spawn_request_id,
+        max(updated_at) AS latest_updated_at
+      FROM commands
+      WHERE type = 'agent.spawn'
+        AND status = 'succeeded'
+        AND json_valid(params)
+        AND coalesce(json_extract(params, '$.registrationConfirmed'), 0) != 1
+        AND coalesce(nullif(json_extract(params, '$.spawnedBy'), ''), '') != ''
+      GROUP BY coalesce(nullif(json_extract(params, '$.spawnRequestId'), ''), correlation_id)
+    )
+    SELECT spawn_request_id, latest_updated_at
+    FROM spawn_groups
+    WHERE spawn_request_id IS NOT NULL
+      AND latest_updated_at <= ?
+    ORDER BY latest_updated_at DESC
+    LIMIT ?
+  `).all(cutoff, MAX_SPAWN_GROUPS_PER_RUN) as SpawnCandidateRow[];
+  const rows = loadSpawnCommandRows(candidateRows.map((row) => row.spawn_request_id));
 
   const failedSpawnCommandIds: string[] = [];
   const notifiedSpawnCommandIds: string[] = [];
   const silencedSpawnCommandIds: string[] = [];
+  const confirmedSpawnCommandIds: string[] = [];
+  let checkedSpawnGroups = 0;
   for (const group of groupSpawnCommands(rows)) {
     if (group.latestUpdatedAt > cutoff) continue;
-    if (hasEverRegisteredAgent(group.spawnRequestId)) continue;
+    checkedSpawnGroups++;
+    if (hasEverRegisteredAgent(group.spawnRequestId)) {
+      confirmedSpawnCommandIds.push(...markSpawnGroupRegistrationConfirmed(group, now));
+      continue;
+    }
 
     const reason = `spawned agent did not register within ${deadlineMs}ms`;
     const failedCommands = group.rows
@@ -70,7 +99,25 @@ export function reapUnregisteredSpawnCommands(
     }
   }
 
-  return { failedSpawnCommandIds, notifiedSpawnCommandIds, silencedSpawnCommandIds };
+  return { failedSpawnCommandIds, notifiedSpawnCommandIds, silencedSpawnCommandIds, confirmedSpawnCommandIds, checkedSpawnGroups };
+}
+
+function loadSpawnCommandRows(spawnRequestIds: string[]): SpawnCommandRow[] {
+  if (spawnRequestIds.length === 0) return [];
+  const placeholders = spawnRequestIds.map(() => "?").join(",");
+  return getDb().query(`
+    SELECT id, params, correlation_id, updated_at
+    FROM commands
+    WHERE type = 'agent.spawn'
+      AND status = 'succeeded'
+      AND json_valid(params)
+      AND coalesce(json_extract(params, '$.registrationConfirmed'), 0) != 1
+      AND (
+        correlation_id IN (${placeholders})
+        OR json_extract(params, '$.spawnRequestId') IN (${placeholders})
+      )
+    ORDER BY updated_at ASC
+  `).all(...spawnRequestIds, ...spawnRequestIds) as SpawnCommandRow[];
 }
 
 function groupSpawnCommands(rows: SpawnCommandRow[]): SpawnCommandGroup[] {
@@ -121,6 +168,24 @@ function hasEverRegisteredAgent(spawnRequestId: string): boolean {
   return Boolean(registration);
 }
 
+function markSpawnGroupRegistrationConfirmed(group: SpawnCommandGroup, now: number): string[] {
+  const confirmed: string[] = [];
+  const stmt = getDb().query(`
+    UPDATE commands
+    SET params = ?
+    WHERE id = ?
+      AND status = 'succeeded'
+  `);
+  for (const row of group.rows) {
+    const params = parseParams(row.params);
+    if (params.registrationConfirmed === true) continue;
+    params.registrationConfirmed = true;
+    params.registrationConfirmedAt = now;
+    if (stmt.run(JSON.stringify(params), row.id).changes > 0) confirmed.push(row.id);
+  }
+  return confirmed;
+}
+
 function parseParams(raw: string): Record<string, unknown> {
   try {
     const parsed = JSON.parse(raw);

package/src/services/task-entity.ts

@@ -34,7 +34,9 @@ import {
   type SetTaskStatusInput,
   type UpdateDeliverableTaskInput,
 } from "../db";
+import { errMessage } from "agent-relay-sdk";
 import { findSpawnCommandByRequestId } from "../commands-db";
+import { defaultIssueRepo } from "../config";
 import { emitTaskChanged } from "../sse";
 import type { CommandStatus, Task, TaskDetail, TaskEvent, TaskGateState, TaskListItem, TaskStatus, WorkspaceRecord } from "../types";
 import { removeSubscriptionsForTask } from "../db/notification-subscriptions";
@@ -43,8 +45,58 @@ import { routeNotification } from "../notification-router";
 import { isAgentExitDoneWhen, stageSatisfiesDoneWhen } from "./task-done-when";
 import { autoSubscribeTaskCoordinator, emitTaskSemanticNotification, taskTransitionForStage, taskTransitionForStatus } from "./task-semantic-events";
 
-export function createTaskEntity(input: CreateDeliverableTaskInput): TaskDetail {
-  const detail = createDeliverableTask(input);
+type CreateTaskEntityInput = CreateDeliverableTaskInput & {
+  issueRefs?: string[];
+  defaultRepo?: string;
+};
+
+const EXPLICIT_ISSUE_REF_RE = /(https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/issues\/[0-9]+(?:[/?#][^\s,)]*)?|[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+#[0-9]+|#[0-9]+)/;
+const ISSUE_SLUG_RE = /(?:^|[\/_\-\s])(?:fix|feat|bug|issue|debug|chore|reverify|reenable)-([1-9][0-9]{0,6})(?=$|[\/_\-\s])/i;
+
+function explicitIssueRefIn(text: string | undefined): string | undefined {
+  return text?.match(EXPLICIT_ISSUE_REF_RE)?.[1];
+}
+
+function slugIssueRefIn(text: string | undefined): string | undefined {
+  const match = text?.match(ISSUE_SLUG_RE)?.[1];
+  return match ? `#${match}` : undefined;
+}
+
+function explicitIssueRefs(input: CreateTaskEntityInput): string[] {
+  return (input.issueRefs ?? []).map((ref) => ref.trim()).filter(Boolean);
+}
+
+function inferIssueRef(input: CreateTaskEntityInput): string | undefined {
+  for (const text of [input.title, input.branch, input.intent, input.context, input.latestSteer]) {
+    const explicit = explicitIssueRefIn(text);
+    if (explicit) return explicit;
+  }
+  for (const text of [input.title, input.branch]) {
+    const slug = slugIssueRefIn(text);
+    if (slug) return slug;
+  }
+  return undefined;
+}
+
+function addInitialIssueRefs(taskId: number, input: CreateTaskEntityInput): TaskDetail {
+  const refs = explicitIssueRefs(input);
+  const inferred = refs.length > 0 ? undefined : inferIssueRef(input);
+  const issueRefs = refs.length > 0 ? refs : inferred ? [inferred] : [];
+  const defaultRepo = input.defaultRepo?.trim() || input.repo?.trim() || defaultIssueRepo();
+  let detail = getTaskDetail(taskId)!;
+  for (const issue of issueRefs) {
+    try {
+      detail = addTaskRef(taskId, { issue, defaultRepo, actor: input.createdBy });
+    } catch (error) {
+      console.warn(`task ${taskId} issue ref '${issue}' could not be linked on create: ${errMessage(error)}`);
+    }
+  }
+  return detail;
+}
+
+export function createTaskEntity(input: CreateTaskEntityInput): TaskDetail {
+  const created = createDeliverableTask(input);
+  const detail = addInitialIssueRefs(created.id, input);
   autoSubscribeTaskCoordinator(input.createdBy, detail.id);
   emitTaskChanged(detail, "task.created");
   emitTaskSemanticNotification({

package/src/settings/registry.ts

@@ -35,6 +35,7 @@ import {
   NOTIFICATIONS_SETTINGS_SCHEMA,
   parseNotificationSettingsKey,
 } from "../notification-settings";
+import { RETENTION_CONFIG_DEFAULTS, RETENTION_CONFIG_SCHEMA, RETENTION_KEY, RETENTION_NAMESPACE } from "../retention-config";
 
 /** Fail-closed default scope — a descriptor that omits scope requires admin to
  *  read and write (#385 owns the scope grammar; this layer only declares it). */
@@ -400,6 +401,16 @@ function seedBuiltInSettings(): void {
     display: { group: "Teams", label: "Team idle watchdog", description: "Coordinator nudge when a team has no busy members.", order: 45 },
   });
 
+  registerSetting({
+    namespace: RETENTION_NAMESPACE,
+    key: RETENTION_KEY,
+    schema: RETENTION_CONFIG_SCHEMA,
+    defaults: RETENTION_CONFIG_DEFAULTS,
+    scope: { read: "settings:read:system", write: "settings:write:system" },
+    tier: "server-runtime",
+    display: { group: "System", label: "Data retention", description: "Retention windows and batch size for high-churn Relay tables.", order: 46 },
+  });
+
   registerSetting({
     namespace: "provider",
     key: "chatCaptureMode",

package/src/sse.ts

@@ -161,6 +161,10 @@ function fanout(event: RelayEvent): void {
     sendNewMessage(event.data as unknown as Message, event.seq);
     return;
   }
+  if (event.type === "message.batch") {
+    sendNewMessages(batchMessages(event.data), event.seq);
+    return;
+  }
   if (event.type === "task.updated" || event.type === "task.created" || event.type === "task.claimed" || event.type === "task.status") {
     sendTaskChanged(event.data as unknown as Task, event.type, event.seq);
     return;
@@ -172,28 +176,62 @@ function fanout(event: RelayEvent): void {
 }
 
 function sendNewMessage(msg: Message, seq?: number): void {
-  const scopedBroadcastAgentIds = msg.to === "broadcast"
-    ? new Set(matchingDeliveryAgents("broadcast", { from: msg.from, channel: msg.channel }).map((agent) => agent.id))
-    : null;
-  const chunk = sseFrame("message.new", msg, seq);
+  sendNewMessages([msg], seq);
+}
+
+function sendNewMessages(messages: Message[], seq?: number): void {
+  if (messages.length === 0) return;
+  const chunks = messages.map((msg, index) => [msg, sseFrame("message.new", msg, seq === undefined ? undefined : seq + index)] as const);
+  const broadcastScopes = new Map<number, Set<string>>();
+  for (const msg of messages) {
+    if (msg.to === "broadcast") {
+      broadcastScopes.set(msg.id, new Set(matchingDeliveryAgents("broadcast", { from: msg.from, channel: msg.channel }).map((agent) => agent.id)));
+    }
+  }
   const agentCache = new Map<string, AgentCard | null>();
   for (const conn of connections.values()) {
-    if (!conn.agentId) {
+    for (const [msg, chunk] of chunks) {
+      if (!conn.agentId) {
+        sendEncoded(conn, chunk);
+        continue;
+      }
+      const scopedBroadcastAgentIds = broadcastScopes.get(msg.id) ?? null;
+      if (scopedBroadcastAgentIds && !scopedBroadcastAgentIds.has(conn.agentId)) continue;
+      if (!messageMatchesAgent(msg, conn.agentId, fanoutAgent(conn.agentId, agentCache))) continue;
       sendEncoded(conn, chunk);
-      continue;
     }
-    if (scopedBroadcastAgentIds && !scopedBroadcastAgentIds.has(conn.agentId)) continue;
-    if (!messageMatchesAgent(msg, conn.agentId, fanoutAgent(conn.agentId, agentCache))) continue;
-    sendEncoded(conn, chunk);
   }
 }
 
+function batchMessages(data: Record<string, unknown>): Message[] {
+  const messages = (data as { messages?: unknown }).messages;
+  return Array.isArray(messages) ? messages as Message[] : [];
+}
+
 export function emitNewMessage(msg: Message) {
   emitRelayEvent({ type: "message.new", source: msg.from, subject: String(msg.id), data: msg as unknown as Record<string, unknown> });
   const notification = notificationForMessage(msg);
   if (notification) emitNotificationCreated(notification);
 }
 
+export function emitNewMessages(messages: Message[]) {
+  if (messages.length === 0) return;
+  if (messages.length === 1) {
+    emitNewMessage(messages[0]!);
+    return;
+  }
+  emitRelayEvent({
+    type: "message.batch",
+    source: messages[0]!.from,
+    subject: `${messages[0]!.id}:${messages.at(-1)!.id}`,
+    data: { messages } as unknown as Record<string, unknown>,
+  });
+  for (const msg of messages) {
+    const notification = notificationForMessage(msg);
+    if (notification) emitNotificationCreated(notification);
+  }
+}
+
 interface RelayInjectionTimelineInput {
   agentId: string;
   category: RelayInjectionCategory;
@@ -328,6 +366,13 @@ function replayEventsToConnection(conn: Connection | undefined, plan: ReplayPlan
 }
 
 function sendReplayEvent(conn: Connection, event: RelayEvent, agentCache: Map<string, AgentCard | null>): void {
+  if (event.type === "message.batch") {
+    for (const [index, msg] of batchMessages(event.data).entries()) {
+      if (conn.agentId && !messageMatchesAgent(msg, conn.agentId, fanoutAgent(conn.agentId, agentCache))) continue;
+      send(conn, "message.new", msg, event.seq + index);
+    }
+    return;
+  }
   if (event.type === "message.new" && conn.agentId) {
     const msg = event.data as unknown as Message;
     if (!messageMatchesAgent(msg, conn.agentId, fanoutAgent(conn.agentId, agentCache))) return;

package/src/workspace-auto-merge.ts

@@ -21,10 +21,13 @@
 import {
   createActivityEvent,
   getActiveMergePause,
+  getWorkspace,
   listOrchestrators,
   listWorkspaces,
   patchWorkspaceMetadata,
+  updateWorkspaceStatus,
 } from "./db";
+import { findLatestCommandByCorrelation } from "./commands-db";
 import { notifyBranchLandFailed, notifyStewardHandoff } from "./branch-landed";
 import { resolveStewardIdentity } from "./steward-identity";
 import { emitCommandEvent } from "./command-events";
@@ -36,17 +39,20 @@ import { isAwaitingReviewerApproval } from "./reviewer-pipeline";
 import { emitWorkspaceTaskSemanticNotifications } from "./services/task-lifecycle";
 import { ensureRepoSteward } from "./steward";
 import { requestWorkspaceMerge, workspaceMergeOrchestrators } from "./workspace-merge";
+import { settleWorkspaceCommand } from "./workspace-command-settle";
+import { CLEAR_MERGE_NO_PROGRESS, MAX_NO_PROGRESS_MERGE_ATTEMPTS, mergeNoProgressCount, noteMergeNoProgress } from "./workspace-merge-progress";
 import { workspaceOwnerOrchestrator } from "./workspace-host";
 import { workspaceActiveClaim } from "./workspace-claim";
 import { DIRTY_WORKTREE_LAND_SKIP_REASON, READY_TO_LAND_STATUSES } from "./workspace-phase";
 import { fetchHostMergePreview } from "./workspace-probe";
-import type { WorkspaceAutoMergePolicy, WorkspaceLandingPolicy, WorkspaceMergePreview, WorkspaceMergeStrategy, WorkspaceRecord } from "./types";
+import type { Command, WorkspaceAutoMergePolicy, WorkspaceLandingPolicy, WorkspaceMergePreview, WorkspaceMergeStrategy, WorkspaceRecord } from "./types";
 import { STEWARD_WAKE_COOLDOWN_MS, stewardFallbackTarget, workspaceAutoMergeEnabled } from "./config";
 import { isPathWithinBase } from "./utils";
 import type { Orchestrator } from "./types";
 
 const WORKSPACE_LAND_STRATEGIES = ["direct", "pr"] as const;
 const WORKSPACE_AUTO_MERGE_POLICIES = ["on-green", "on-approval", "manual"] as const;
+export { CLEAR_MERGE_NO_PROGRESS, MAX_NO_PROGRESS_MERGE_ATTEMPTS, mergeNoProgressCount, noteMergeNoProgress } from "./workspace-merge-progress";
 
 type AutoMergeRequestOptions = {
   requestedBy: "auto-merge";
@@ -174,41 +180,13 @@ export function wakeRepoSteward(ws: WorkspaceRecord, reason: string): string | n
   }
 }
 
-// #638 — auto-merge loop breaker. A `workspace.merge` the orchestrator settles `failed`
-// (no progress: origin moved ahead of local base, a replay conflict the clean-preview
-// didn't predict, a push race) returns the workspace to a landable status
-// (`review_requested`). The on-settle re-trigger (routes/commands.ts → scheduleRepoMerge)
-// then re-dispatches it within a few seconds — forever. That's a silent merge-command
-// storm that churns the per-repo lease and 409s every manual land (the live incident).
-// Cap consecutive no-progress attempts per workspace; past the cap, stop dispatching and
-// escalate. The count is incremented by the merge-result handler (server owns the
-// transition) and cleared on genuine progress or a fresh ready/request-review hand-off.
-export const MAX_NO_PROGRESS_MERGE_ATTEMPTS = 3;
-
 // Don't re-escalate a backed-off lane more than once per this window.
 const NO_PROGRESS_ESCALATION_COOLDOWN_MS = 30 * 60 * 1000;
 export const AUTO_MERGE_ERROR_BACKOFF_MS = 3_000;
 export const AUTO_MERGE_WATCHDOG_STALE_MS = 5 * 60 * 1000;
+export const IN_FLIGHT_WORKSPACE_WATCHDOG_AGE_MS = 20 * 60 * 1000;
 
-/** The recorded count of consecutive no-progress merge attempts for a workspace (#638). */
-export function mergeNoProgressCount(metadata: Record<string, unknown>): number {
-  const n = metadata.autoMergeNoProgressCount;
-  return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : 0;
-}
-
-/** Metadata patch recording one more no-progress merge attempt (#638). Applied by the
- * merge-result handler when a dispatched merge settles `failed` without landing. */
-export function noteMergeNoProgress(metadata: Record<string, unknown>): Record<string, unknown> {
-  return { autoMergeNoProgressCount: mergeNoProgressCount(metadata) + 1, autoMergeNoProgressAt: Date.now() };
-}
-
-/** Metadata patch that clears the no-progress back-off — genuine progress (a land/recycle)
- * or a fresh hand-off means the lane is worth attempting again (#638). */
-export const CLEAR_MERGE_NO_PROGRESS: Record<string, unknown> = {
-  autoMergeNoProgressCount: 0,
-  autoMergeNoProgressAt: undefined,
-  autoMergeBackedOffAt: undefined,
-};
+const TERMINAL_COMMAND_STATUSES = new Set(["succeeded", "failed", "timed_out", "rejected", "canceled"]);
 
 // Surface a lane auto-merge can't advance (#638): wake the repo steward (if enabled) and
 // route a stranded-escalation notice to the configured fallback / workspace owner, so a
@@ -558,11 +536,93 @@ export function resetRepoMergeSchedulerForTests(): void {
   autoMergeWatchdogStartedAt = Date.now();
 }
 
+function commandIsTerminal(command: Command | null): boolean {
+  return Boolean(command && TERMINAL_COMMAND_STATUSES.has(command.status));
+}
+
+function latestWorkspaceCommand(ws: WorkspaceRecord): Command | null {
+  const type = ws.status === "merge_planned" ? "workspace.merge" : "workspace.cleanup";
+  return findLatestCommandByCorrelation(type, ws.id);
+}
+
+function recoverAgedInFlightWorkspaces(now: number): Record<string, string[]> {
+  const oldEnough = (ws: WorkspaceRecord) => now - ws.updatedAt >= IN_FLIGHT_WORKSPACE_WATCHDOG_AGE_MS;
+  const recoveredMergePlanned: string[] = [];
+  const recoveredCleanupRequested: string[] = [];
+  const settledTerminal: string[] = [];
+  const stillActive: string[] = [];
+
+  for (const ws of listWorkspaces().filter((row) =>
+    row.mode === "isolated"
+    && Boolean(row.worktreePath)
+    && (row.status === "merge_planned" || row.status === "cleanup_requested")
+    && oldEnough(row),
+  )) {
+    const command = latestWorkspaceCommand(ws);
+    if (command && !commandIsTerminal(command)) {
+      stillActive.push(ws.id);
+      continue;
+    }
+    if (command) {
+      settleWorkspaceCommand(command, { onMergeSettled: scheduleRepoMerge });
+      settledTerminal.push(ws.id);
+    }
+    const fresh = getWorkspace(ws.id);
+    if (!fresh) continue;
+    if (fresh.status === "merge_planned") {
+      const reason = command
+        ? `workspace.merge ${command.status} without settling workspace state`
+        : "workspace.merge command missing";
+      updateWorkspaceStatus(fresh.id, "review_requested", {
+        mergeCommandId: command?.id,
+        mergeError: reason,
+        inFlightWatchdogRecoveredAt: now,
+        ...noteMergeNoProgress(fresh.metadata),
+      });
+      recoveredMergePlanned.push(fresh.id);
+      scheduleRepoMerge(fresh.repoRoot);
+      createActivityEvent({
+        clientId: `workspace-inflight-watchdog-merge-${fresh.id}-${now}`,
+        kind: "state",
+        title: "Recovered stuck workspace merge",
+        body: `${fresh.branch ?? fresh.id} was stuck in merge_planned; returned to review_requested (${reason})`,
+        meta: fresh.branch ?? fresh.id,
+        icon: "ti-refresh-alert",
+        view: "orchestrators",
+        metadata: { source: "server", maintenanceJobId: "workspace-auto-merge-watchdog", workspaceId: fresh.id, commandId: command?.id, commandStatus: command?.status },
+      });
+    } else if (fresh.status === "cleanup_requested") {
+      const reason = command
+        ? `workspace.cleanup ${command.status} without cleaning workspace`
+        : "workspace.cleanup command missing";
+      updateWorkspaceStatus(fresh.id, "active", {
+        cleanupCommandId: command?.id,
+        cleanupError: reason,
+        inFlightWatchdogRecoveredAt: now,
+      });
+      recoveredCleanupRequested.push(fresh.id);
+      createActivityEvent({
+        clientId: `workspace-inflight-watchdog-cleanup-${fresh.id}-${now}`,
+        kind: "state",
+        title: "Recovered stuck workspace cleanup",
+        body: `${fresh.branch ?? fresh.id} was stuck in cleanup_requested; returned to active (${reason})`,
+        meta: fresh.branch ?? fresh.id,
+        icon: "ti-refresh-alert",
+        view: "orchestrators",
+        metadata: { source: "server", maintenanceJobId: "workspace-auto-merge-watchdog", workspaceId: fresh.id, commandId: command?.id, commandStatus: command?.status },
+      });
+    }
+  }
+
+  return { recoveredMergePlanned, recoveredCleanupRequested, settledTerminal, stillActive };
+}
+
 export function runAutoMergeWatchdog(
   opts: { now?: number; staleMs?: number; log?: (message: string) => void } = {},
 ): Record<string, unknown> {
   const now = opts.now ?? Date.now();
   const staleMs = opts.staleMs ?? AUTO_MERGE_WATCHDOG_STALE_MS;
+  const inFlightRecovery = recoverAgedInFlightWorkspaces(now);
   const ready = landableWorkspaces();
   const repoRoots = [...new Set(ready.map((ws) => ws.repoRoot).filter(Boolean))];
   const repoStaleForMs = Object.fromEntries(repoRoots.map((repoRoot) => {
@@ -571,10 +631,10 @@ export function runAutoMergeWatchdog(
     return [repoRoot, now - lastProgressAt];
   }));
   const staleForMs = Object.values(repoStaleForMs).reduce((max, value) => Math.max(max, value), 0);
-  if (!ready.length) return { readyCount: 0, staleForMs, repoStaleForMs, restartedRepoRoots: [] };
+  if (!ready.length) return { readyCount: 0, staleForMs, repoStaleForMs, restartedRepoRoots: [], inFlightRecovery };
 
   const restartedRepoRoots = repoRoots.filter((repoRoot) => repoStaleForMs[repoRoot]! >= staleMs);
-  if (!restartedRepoRoots.length) return { readyCount: ready.length, staleForMs, repoStaleForMs, restartedRepoRoots: [] };
+  if (!restartedRepoRoots.length) return { readyCount: ready.length, staleForMs, repoStaleForMs, restartedRepoRoots: [], inFlightRecovery };
 
   const log = opts.log ?? console.warn;
   log(`[workspace-auto-merge] Watchdog: no auto-merge cycle completed for ${staleForMs}ms while ${ready.length} ready workspace(s) exist; restarting ${restartedRepoRoots.length} repo merge loop(s)`);
@@ -583,7 +643,7 @@ export function runAutoMergeWatchdog(
     if (existing) existing.rerun = true;
     else scheduleRepoMerge(repoRoot);
   }
-  return { readyCount: ready.length, staleForMs, repoStaleForMs, restartedRepoRoots };
+  return { readyCount: ready.length, staleForMs, repoStaleForMs, restartedRepoRoots, inFlightRecovery };
 }
 
 // Drain the landable rows for ONE repo (the event-driven fast path). Scoped to the