agent-relay-server 0.110.0 → 0.111.0

package/src/db/task-entity.ts

@@ -592,6 +592,7 @@ export interface ListDeliverableTasksFilter {
   status?: string;
   deliverableStage?: string;
   teamId?: string;
+  createdBy?: string;
   limit?: number;
 }
 
@@ -601,6 +602,7 @@ export function listDeliverableTasks(filter: ListDeliverableTasksFilter = {}): T
   if (filter.status) { conditions.push("status = ?"); params.push(filter.status); }
   if (filter.deliverableStage) { conditions.push("deliverable_stage = ?"); params.push(filter.deliverableStage); }
   if (filter.teamId) { conditions.push("team_id = ?"); params.push(filter.teamId); }
+  if (filter.createdBy) { conditions.push("created_by = ?"); params.push(filter.createdBy); }
   const limit = Math.min(Math.max(filter.limit ?? 100, 1), 500);
   params.push(limit);
   return (getDb().query(`${TASK_SELECT} WHERE ${conditions.join(" AND ")} ORDER BY updated_at DESC LIMIT ?`).all(...params as any[]) as any[]).map(rowToTask);

package/src/mcp-notification-subscription-tools.ts

@@ -21,8 +21,9 @@ import { getTaskEntity } from "./services/task-entity";
 import { cleanString } from "./validation";
 import { NOTIFICATION_TYPES, type NotificationScope, type NotificationType } from "./notification-types";
 import { previewNotificationRouting, whyNotified } from "./notification-router";
+import { TASK_SEMANTIC_NOTIFICATION_TYPES } from "./services/task-semantic-events";
 
-const TASK_NOTIFICATION_TYPES = ["task.created", "task.started", "task.blocked", "task.needs_decision", "task.landed", "task.closed"] as const satisfies readonly NotificationType[];
+const TASK_NOTIFICATION_TYPES = TASK_SEMANTIC_NOTIFICATION_TYPES as readonly NotificationType[];
 
 export const NOTIFICATION_SUBSCRIPTION_TOOLS = [
   {

package/src/notification-rules.ts

@@ -272,6 +272,22 @@ registerDefaultAudienceRules("message.new", [
   audiencePredicates.threadParticipant(),
 ]);
 
-for (const type of ["task.created", "task.started", "task.blocked", "task.needs_decision", "task.landed", "task.closed"] as const) {
+for (const type of [
+  "task.created",
+  "task.started",
+  "task.blocked",
+  "task.needs_decision",
+  "task.gate_failed",
+  "task.committed_on_branch",
+  "task.review_requested",
+  "task.land_conflict",
+  "task.landed",
+  "task.landed_on_main",
+  "task.closed",
+  "task.working",
+  "task.done",
+  "task.deploying",
+  "task.deployed",
+] as const) {
   registerDefaultAudienceRules(type, []);
 }

package/src/notification-types.ts

@@ -7,8 +7,17 @@ export type NotificationType =
   | "task.started"
   | "task.blocked"
   | "task.needs_decision"
+  | "task.gate_failed"
+  | "task.committed_on_branch"
+  | "task.review_requested"
+  | "task.land_conflict"
   | "task.landed"
+  | "task.landed_on_main"
   | "task.closed"
+  | "task.working"
+  | "task.done"
+  | "task.deploying"
+  | "task.deployed"
   | "agent.ready"
   | "agent.exited"
   | "agent.spawn_failed"
@@ -94,8 +103,17 @@ export const DEFAULT_TTL_MS: Record<NotificationType, number | null> = {
   "task.started": null,
   "task.blocked": null,
   "task.needs_decision": null,
+  "task.gate_failed": null,
+  "task.committed_on_branch": null,
+  "task.review_requested": null,
+  "task.land_conflict": null,
   "task.landed": null,
+  "task.landed_on_main": null,
   "task.closed": null,
+  "task.working": null,
+  "task.done": null,
+  "task.deploying": null,
+  "task.deployed": null,
   "agent.ready": null,
   "agent.exited": null,
   "agent.spawn_failed": null,

package/src/reviewer-pipeline.ts

@@ -5,6 +5,7 @@ import { getSpawnPolicy } from "./config-store";
 import { getLifecycleManager } from "./lifecycle-manager";
 import { routeNotification } from "./notification-router";
 import { getWorkspace, listAgents, patchWorkspaceMetadata, updateWorkspaceStatus } from "./db";
+import { emitWorkspaceTaskSemanticNotifications } from "./services/task-lifecycle";
 import type { Command, WorkspaceMergePreview, WorkspaceRecord } from "./types";
 
 type ReviewDecision = "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED";
@@ -59,6 +60,18 @@ export function handleReviewerMergeResult(command: Command, result: Record<strin
     compareRef,
   });
   if (!updated) return false;
+  emitWorkspaceTaskSemanticNotifications({
+    workspace: updated,
+    transition: "review-requested",
+    actor: "reviewer-pipeline",
+    occurrenceKey: `workspace-review:${workspace.id}:${command.id}`,
+    outcome: {
+      reviewer: target,
+      prUrl,
+      prNumber,
+      compareRef,
+    },
+  });
 
   // Obligation (ttl null by type default): a review request must reach the reviewer even if they're
   // offline a while — it's not a bystander notice.

package/src/routes/commands.ts

@@ -11,6 +11,7 @@ import { getCompactionWatch } from "../compaction-watch";
 import { isRecord } from "agent-relay-sdk";
 import { authContextFromRequest } from "../services/auth-context";
 import { commandAuthorizationResource as dispatchCommandAuthorizationResource, dispatchCommand } from "../services/dispatch-command";
+import { emitWorkspaceTaskSemanticNotifications } from "../services/task-lifecycle";
 import { ServiceAuthError } from "../services/errors";
 import { notifyBaseWorktreeStrand, notifyBranchLandFailed, notifyBranchLanded } from "../branch-landed";
 import { applyIdleRefreshResult } from "../maintenance/workspaces";
@@ -305,6 +306,19 @@ export const patchCommand: Handler = async (req, params) => {
             mergeError: command.error ?? "merge failed",
             ...noteMergeNoProgress(current.metadata),
           });
+          if (nextStatus === "conflict") {
+            emitWorkspaceTaskSemanticNotifications({
+              workspace: current,
+              transition: "land-conflict",
+              actor: "workspace-merge",
+              occurrenceKey: `workspace-merge-conflict:${current.id}:${command.id}`,
+              outcome: {
+                reason: command.error ?? "merge failed",
+                commandId: command.id,
+                status: nextStatus,
+              },
+            });
+          }
           notifyBranchLandFailed({
             workspace: current,
             commandId: command.id,

package/src/routes/tasks.ts

@@ -76,6 +76,7 @@ export const getTaskEntities: Handler = (req) => {
     status: url.searchParams.get("status") ?? undefined,
     deliverableStage: url.searchParams.get("deliverableStage") ?? undefined,
     teamId: url.searchParams.get("teamId") ?? undefined,
+    createdBy: url.searchParams.get("createdBy") ?? undefined,
     limit: limitRaw ?? 100,
   }));
 };

package/src/services/spawn-agent.ts

@@ -42,6 +42,7 @@ import { applyDefaultSharedMcp, type SharedMcpSpawnOverride } from "../shared-mc
 import { autoSeedProjectForCwd } from "./project";
 import { hydrateTaskContext, projectTaskHydration } from "./task-context-hydration";
 import { recordTaskEntityDispatchDecision } from "./task-entity";
+import { autoSubscribeTaskCoordinator } from "./task-semantic-events";
 import { dispatchTask } from "../task-dispatcher";
 import { hasComponentScope, isComponentAuthorizedFor } from "../security";
 import { isPathWithinBase } from "../utils";
@@ -586,6 +587,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
         requestedBy,
         ...(hydratedTask?.steer ? { steer: hydratedTask.steer } : {}),
       });
+      autoSubscribeTaskCoordinator(requestedBy, input.taskId);
     } catch (err) {
       console.warn(`task ${input.taskId} spawn attribution skipped: ${errMessage(err)}`);
     }

package/src/services/task-entity.ts

@@ -29,16 +29,17 @@ import {
 } from "../db";
 import { emitTaskChanged } from "../sse";
 import type { Task, TaskDetail, TaskEvent, TaskGateState } from "../types";
-import { emitTaskSemanticNotification, taskTransitionForStatus } from "./task-semantic-events";
+import { removeSubscriptionsForTask } from "../db/notification-subscriptions";
+import { autoSubscribeTaskCoordinator, emitTaskSemanticNotification, taskTransitionForStage, taskTransitionForStatus } from "./task-semantic-events";
 
 export function createTaskEntity(input: CreateDeliverableTaskInput): TaskDetail {
   const detail = createDeliverableTask(input);
+  autoSubscribeTaskCoordinator(input.createdBy, detail.id);
   emitTaskChanged(detail, "task.created");
   emitTaskSemanticNotification({
     task: detail,
     transition: "created",
     actor: input.createdBy,
-    recipients: input.createdBy ? [input.createdBy] : [],
     occurrenceKey: latestTaskEventOccurrence(detail.id, "task.created"),
   });
   return detail;
@@ -68,23 +69,27 @@ export function setTaskEntityStatus(id: number, input: SetTaskStatusInput): Task
       task: detail,
       transition,
       actor: input.actor,
-      recipients: detail.createdBy ? [detail.createdBy] : [],
       occurrenceKey: latestTaskEventOccurrence(detail.id, `status:${detail.status}`),
     });
   }
+  if (isTerminalTaskStatus(detail.status)) removeSubscriptionsForTask(detail.id);
   return detail;
 }
 
+function isTerminalTaskStatus(status: Task["status"]): boolean {
+  return status === "done" || status === "failed" || status === "canceled";
+}
+
 export function setTaskEntityStage(id: number, input: SetTaskStageInput): TaskDetail {
   const before = getTaskDetail(id);
   const detail = setTaskStage(id, input);
   emitTaskChanged(detail, "task.stage");
-  if (input.actor !== "task-lifecycle" && before?.deliverableStage !== "landed-on-main" && detail.deliverableStage === "landed-on-main") {
+  const transition = taskTransitionForStage(detail.deliverableStage);
+  if (input.actor !== "task-lifecycle" && transition && before?.deliverableStage !== detail.deliverableStage) {
     emitTaskSemanticNotification({
       task: detail,
-      transition: "landed",
+      transition,
       actor: input.actor,
-      recipients: detail.createdBy ? [detail.createdBy] : [],
       branch: detail.branch,
       occurrenceKey: latestTaskEventOccurrence(detail.id, `stage:${detail.deliverableStage}`),
     });
@@ -111,6 +116,15 @@ export function recordTaskEntityGate(id: number, input: RecordGateInput): { gate
   const gate = recordGate(id, input);
   const detail = getTaskDetail(id);
   if (detail) emitTaskChanged(detail, "task.gate");
+  if (detail && gate.status === "fail") {
+    emitTaskSemanticNotification({
+      task: detail,
+      transition: "gate-failed",
+      actor: input.actor,
+      occurrenceKey: latestTaskEventOccurrence(detail.id, `gate:${gate.gate}`),
+      outcome: { gate: gate.gate, status: gate.status, ...(gate.detail ? { detail: gate.detail } : {}) },
+    });
+  }
   return { gate, gates: detail?.gates ?? [] };
 }
 

package/src/services/task-lifecycle.ts

@@ -36,7 +36,7 @@ import { requestTransientAgentShutdown } from "./transient-agent-reaper";
 import { emitRelayEvent } from "../events";
 import { routeNotification } from "../notification-router";
 import { resolveCoordinatorAgentId } from "../steward-identity";
-import { emitTaskSemanticNotification } from "./task-semantic-events";
+import { emitTaskSemanticNotification, type TaskSemanticTransition } from "./task-semantic-events";
 import type { IssueRef, TaskDeliverableStage, TaskGateState, WorkspaceRecord } from "../types";
 import type { IssueTrackerAdapter } from "../issue-tracker";
 
@@ -179,7 +179,7 @@ function landKeyFor(input: LandedTaskLifecycleInput): string {
 // `agent.spawn_requested` attribution keyed on the worker's meta.spawnRequestId (fire-and-forget,
 // owner not yet backfilled), and the Task's recorded branch column. Deduped + ordered. Returns []
 // for an ordinary non-task branch → the land is a strict no-op (behavior byte-identical).
-function resolveBoundTaskIds(workspace: LifecycleWorkspace): number[] {
+export function boundTaskIdsForWorkspace(workspace: LifecycleWorkspace): number[] {
   const ids = new Set<number>();
   const owner = workspace.ownerAgentId?.trim();
   if (owner) {
@@ -195,6 +195,35 @@ function resolveBoundTaskIds(workspace: LifecycleWorkspace): number[] {
   return [...ids].sort((a, b) => a - b);
 }
 
+export function emitWorkspaceTaskSemanticNotifications(input: {
+  workspace: LifecycleWorkspace;
+  transition: TaskSemanticTransition;
+  actor?: string;
+  occurrenceKey?: string;
+  outcome?: Record<string, unknown>;
+  sha?: string;
+}): number[] {
+  const emitted: number[] = [];
+  const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
+  for (const taskId of boundTaskIdsForWorkspace(input.workspace)) {
+    const task = getTaskDetail(taskId);
+    if (!task) continue;
+    emitTaskSemanticNotification({
+      task,
+      transition: input.transition,
+      actor: input.actor,
+      recipients: coordinator ? [coordinator] : [],
+      workspaceId: input.workspace.id,
+      branch: input.workspace.branch,
+      ...(input.sha ? { sha: input.sha } : {}),
+      ...(input.occurrenceKey ? { occurrenceKey: input.occurrenceKey } : {}),
+      ...(input.outcome ? { outcome: input.outcome } : {}),
+    });
+    emitted.push(taskId);
+  }
+  return emitted;
+}
+
 // --- reap signal (decoupled from task-done) ----------------------------------------------------
 interface ReapResult {
   reaped: boolean;
@@ -382,7 +411,7 @@ function emitDeliverableLandedEvent(input: LandedTaskLifecycleInput, outcome: Ta
   const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
   emitTaskSemanticNotification({
     task,
-    transition: "landed",
+    transition: "landed-on-main",
     actor: "task-lifecycle",
     recipients: coordinator ? [coordinator] : [],
     workspaceId: input.workspace.id,
@@ -401,7 +430,7 @@ function emitDeliverableErrorReceipt(input: LandedTaskLifecycleInput, outcome: T
     type: "task.landed",
     scope: {
       taskId: String(outcome.taskId),
-      transition: "landed",
+      transition: "landed-on-main",
       landKey,
       ...(input.workspace.ownerAgentId ? { agentId: input.workspace.ownerAgentId, author: input.workspace.ownerAgentId } : {}),
       ...(task?.createdBy ? { parent: task.createdBy } : {}),
@@ -417,8 +446,8 @@ function emitDeliverableErrorReceipt(input: LandedTaskLifecycleInput, outcome: T
         kind: "task.lifecycle-error",
         notification: "task-lifecycle-error",
         taskId: outcome.taskId,
-        transition: "landed",
-        semanticEvent: "task.landed",
+        transition: "landed-on-main",
+        semanticEvent: "task.landed-on-main",
         workspaceId: input.workspace.id,
         branch: input.workspace.branch,
         ...(input.mergedSha ? { sha: input.mergedSha } : {}),
@@ -442,7 +471,7 @@ export async function handleLandedTaskLifecycle(
   const log = opts.log ?? ((message: string) => console.warn(message));
   // Non-default-base lands never drive a deliverable (mirror the issue-lifecycle guard).
   if ((input.workspace.baseRef ?? "main") !== "main") return { handled: false, reason: "non-default-branch", tasks: [] };
-  const taskIds = resolveBoundTaskIds(input.workspace);
+  const taskIds = boundTaskIdsForWorkspace(input.workspace);
   if (taskIds.length === 0) return { handled: false, reason: "no-bound-task", tasks: [] };
 
   const diffSummary = landedDiffSummary(input, log);

package/src/services/task-semantic-events.ts

@@ -1,30 +1,75 @@
 import { getAgent } from "../db";
+import { addSubscription } from "../db/notification-subscriptions";
 import { emitRelayEvent } from "../events";
+import { notifySystemMessage } from "../notify";
 import type { NotificationScope, NotificationType } from "../notification-types";
 import { routeNotification } from "../notification-router";
 import { resolveAudience } from "../notification-rules";
-import type { Task, TaskBlocker, TaskStatus } from "../types";
+import type { Task, TaskBlocker, TaskDeliverableStage, TaskDetail, TaskIssueLink, TaskStatus } from "../types";
 
-export type TaskSemanticTransition = "created" | "started" | "blocked" | "needs-decision" | "landed" | "closed";
+export type TaskSemanticTransition =
+  | KnownTaskSemanticTransition
+  | (string & {});
 
-const TASK_NOTIFICATION_TYPE: Record<TaskSemanticTransition, NotificationType> = {
+type KnownTaskSemanticTransition =
+  | "created"
+  | "working"
+  | "blocked"
+  | "needs-decision"
+  | "gate-failed"
+  | "committed-on-branch"
+  | "review-requested"
+  | "land-conflict"
+  | "landed-on-main"
+  | "done"
+  | "deploying"
+  | "deployed";
+
+export type TaskSemanticClassification = "action-required" | "status-pulse" | "suppressed";
+
+const TASK_NOTIFICATION_TYPE: Record<KnownTaskSemanticTransition, NotificationType> = {
   created: "task.created",
-  started: "task.started",
+  working: "task.working",
   blocked: "task.blocked",
   "needs-decision": "task.needs_decision",
-  landed: "task.landed",
-  closed: "task.closed",
+  "gate-failed": "task.gate_failed",
+  "committed-on-branch": "task.committed_on_branch",
+  "review-requested": "task.review_requested",
+  "land-conflict": "task.land_conflict",
+  "landed-on-main": "task.landed_on_main",
+  done: "task.done",
+  deploying: "task.deploying",
+  deployed: "task.deployed",
 };
+const UNKNOWN_TASK_NOTIFICATION_TYPE: NotificationType = "task.working";
+export const TASK_SEMANTIC_NOTIFICATION_TYPES = Object.values(TASK_NOTIFICATION_TYPE);
 
 export function taskTransitionForStatus(status: TaskStatus, blockers: TaskBlocker[] | undefined): TaskSemanticTransition | null {
-  if (status === "claimed" || status === "in_progress") return "started";
+  if (status === "claimed" || status === "in_progress") return "working";
   if (status === "blocked") {
     return blockers?.some((blocker) => blocker.type === "decision") ? "needs-decision" : "blocked";
   }
-  if (status === "done" || status === "failed" || status === "canceled") return "closed";
+  if (status === "done") return "done";
+  if (status === "failed") return "gate-failed";
+  return null;
+}
+
+export function taskTransitionForStage(stage: TaskDeliverableStage | undefined): TaskSemanticTransition | null {
+  if (stage === "committed-on-branch") return "committed-on-branch";
+  if (stage === "landed-on-main") return "landed-on-main";
+  if (stage === "deploying") return "deploying";
+  if (stage === "deployed") return "deployed";
   return null;
 }
 
+export function classifyTaskSemanticTransition(transition: TaskSemanticTransition): TaskSemanticClassification {
+  if (transition === "blocked" || transition === "needs-decision" || transition === "gate-failed" || transition === "review-requested" || transition === "land-conflict") {
+    return "action-required";
+  }
+  if (transition === "created") return "suppressed";
+  return "status-pulse";
+}
+
 export interface TaskSemanticNotificationInput {
   task: Task;
   transition: TaskSemanticTransition;
@@ -38,15 +83,55 @@ export interface TaskSemanticNotificationInput {
   outcome?: Record<string, unknown>;
 }
 
+const TASK_STATUS_PULSE_BATCH_MS = 1000;
+const TASK_NOTIFICATION_TRANSITIONS = Object.keys(TASK_NOTIFICATION_TYPE) as KnownTaskSemanticTransition[];
+
+interface StatusPulseDigestItem {
+  taskId: number;
+  title: string;
+  transition: TaskSemanticTransition;
+  classification: "status-pulse";
+  issue?: Pick<TaskIssueLink, "provider" | "repo" | "externalKey" | "url" | "title">;
+  branch?: string;
+  sha?: string;
+  outcome?: Record<string, unknown>;
+  occurredAt: number;
+}
+
+interface StatusPulseBatch {
+  timer?: ReturnType<typeof setTimeout>;
+  items: StatusPulseDigestItem[];
+}
+
+const statusPulseBatches = new Map<string, StatusPulseBatch>();
+
+export function autoSubscribeTaskCoordinator(agentId: string | undefined, taskId: number): boolean {
+  const cleaned = agentId?.trim();
+  if (!cleaned || !getAgent(cleaned)) return false;
+  for (const transition of TASK_NOTIFICATION_TRANSITIONS) {
+    addSubscription({
+      agentId: cleaned,
+      type: TASK_NOTIFICATION_TYPE[transition],
+      mode: "opt_in",
+      scopeMatch: { taskId: String(taskId) },
+    });
+  }
+  return true;
+}
+
 export function emitTaskSemanticNotification(input: TaskSemanticNotificationInput): void {
-  const type = TASK_NOTIFICATION_TYPE[input.transition];
+  const type = TASK_NOTIFICATION_TYPE[input.transition as KnownTaskSemanticTransition] ?? UNKNOWN_TASK_NOTIFICATION_TYPE;
   const scope = taskNotificationScope(input);
   const semanticEvent = `task.${input.transition}`;
+  const classification = classifyTaskSemanticTransition(input.transition);
+  const issue = primaryIssue(input.task);
   const eventData = {
     taskId: input.task.id,
     transition: input.transition,
+    classification,
     semanticEvent,
     title: input.task.title,
+    ...(issue ? { issue } : {}),
     status: input.task.status,
     deliverableStage: input.task.deliverableStage,
     ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
@@ -72,7 +157,24 @@ export function emitTaskSemanticNotification(input: TaskSemanticNotificationInpu
     .map((agentId) => ({ agentId, matchedRule: "task-stakeholder" }));
 
   const recipients = [...subscriptionAudience, ...explicit];
-  if (recipients.length === 0) return;
+  if (recipients.length === 0 || classification === "suppressed") return;
+
+  if (classification === "status-pulse") {
+    for (const recipient of dedupeRecipients(recipients)) {
+      enqueueStatusPulse(recipient.agentId, {
+        taskId: input.task.id,
+        title: input.task.title,
+        transition: input.transition,
+        classification,
+        ...(issue ? { issue } : {}),
+        ...(input.branch ? { branch: input.branch } : {}),
+        ...(input.sha ? { sha: input.sha } : {}),
+        ...(input.outcome ? { outcome: input.outcome } : {}),
+        occurredAt: Date.now(),
+      });
+    }
+    return;
+  }
 
   routeNotification({
     type,
@@ -85,9 +187,13 @@ export function emitTaskSemanticNotification(input: TaskSemanticNotificationInpu
       payload: {
         kind: "task.transition",
         notification: "task-transition",
+        classification,
+        actionRequired: true,
         taskId: input.task.id,
+        ...(issue ? { issue } : {}),
         transition: input.transition,
         semanticEvent,
+        needed: taskNotificationNeeded(input),
         ...(input.outcome ? { outcome: input.outcome } : {}),
         ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
         ...(input.branch ? { branch: input.branch } : {}),
@@ -99,6 +205,82 @@ export function emitTaskSemanticNotification(input: TaskSemanticNotificationInpu
   });
 }
 
+function dedupeRecipients(recipients: Array<{ agentId: string; matchedRule: string }>): Array<{ agentId: string; matchedRule: string }> {
+  const seen = new Set<string>();
+  const out: Array<{ agentId: string; matchedRule: string }> = [];
+  for (const recipient of recipients) {
+    if (seen.has(recipient.agentId)) continue;
+    seen.add(recipient.agentId);
+    out.push(recipient);
+  }
+  return out;
+}
+
+function enqueueStatusPulse(agentId: string, item: StatusPulseDigestItem): void {
+  const batch = statusPulseBatches.get(agentId) ?? { items: [] };
+  batch.items.push(item);
+  if (!batch.timer) {
+    batch.timer = setTimeout(() => flushTaskStatusPulses(agentId), TASK_STATUS_PULSE_BATCH_MS);
+  }
+  statusPulseBatches.set(agentId, batch);
+}
+
+export function flushTaskStatusPulses(agentId?: string): void {
+  const targets = agentId ? [agentId] : [...statusPulseBatches.keys()];
+  for (const target of targets) {
+    const batch = statusPulseBatches.get(target);
+    if (!batch) continue;
+    if (batch.timer) clearTimeout(batch.timer);
+    statusPulseBatches.delete(target);
+    if (batch.items.length === 0) continue;
+    const items = compactStatusPulseItems(batch.items);
+    notifySystemMessage(target, {
+      subject: `Task status pulse (${items.length})`,
+      body: taskStatusPulseBody(items),
+      payload: {
+        kind: "task.status-pulse",
+        notification: "task-status-pulse",
+        classification: "status-pulse",
+        actionRequired: false,
+        taskIds: [...new Set(items.map((item) => item.taskId))],
+        events: items.map((item) => ({
+          taskId: item.taskId,
+          title: item.title,
+          transition: item.transition,
+          classification: item.classification,
+          ...(item.issue ? { issue: item.issue } : {}),
+          ...(item.branch ? { branch: item.branch } : {}),
+          ...(item.sha ? { sha: item.sha } : {}),
+          ...(item.outcome ? { outcome: item.outcome } : {}),
+          occurredAt: item.occurredAt,
+        })),
+      },
+      idempotencyKey: `task:status-pulse:${target}:${items.map((item) => `${item.taskId}:${item.transition}:${item.occurredAt}`).join("|")}`,
+      replyExpected: false,
+      maxAgeSeconds: null,
+    });
+  }
+}
+
+function compactStatusPulseItems(items: StatusPulseDigestItem[]): StatusPulseDigestItem[] {
+  const byKey = new Map<string, StatusPulseDigestItem>();
+  for (const item of items) byKey.set(`${item.taskId}:${item.transition}`, item);
+  return [...byKey.values()].sort((a, b) => a.occurredAt - b.occurredAt);
+}
+
+function taskStatusPulseBody(items: StatusPulseDigestItem[]): string {
+  const lines = ["Task status pulse:"];
+  for (const item of items) {
+    const bits = [`#${item.taskId}`, item.transition, item.title];
+    const issue = issueLabel(item.issue);
+    if (issue) bits.push(issue);
+    if (item.branch) bits.push(`branch ${item.branch}`);
+    if (item.sha) bits.push(`sha ${item.sha.slice(0, 12)}`);
+    lines.push(`- ${bits.join(" - ")}`);
+  }
+  return lines.join("\n");
+}
+
 function taskNotificationIdempotencyKey(input: TaskSemanticNotificationInput): string | undefined {
   if (input.landKey) return `task:${input.task.id}:transition:${input.transition}:${input.landKey}`;
   if (input.occurrenceKey) return `task:${input.task.id}:transition:${input.transition}:occurrence:${input.occurrenceKey}`;
@@ -125,13 +307,59 @@ function taskNotificationSubject(input: TaskSemanticNotificationInput): string {
 }
 
 function taskNotificationBody(input: TaskSemanticNotificationInput): string {
-  if (input.transition === "landed") {
-    const bits = [`Task #${input.task.id} landed: ${input.task.title}`];
+  const issue = issueLabel(primaryIssue(input.task));
+  if (input.transition === "landed-on-main") {
+    const bits = [`Task #${input.task.id} landed on main: ${input.task.title}`];
     if (input.sha) bits.push(`sha ${input.sha.slice(0, 12)}`);
     const gatesPassed = input.outcome?.gatesPassed;
     if (typeof gatesPassed === "boolean") bits.push(gatesPassed ? "gates passed" : "gates not verified");
     if (input.outcome?.statusAdvanced === true) bits.push("closed");
+    if (issue) bits.push(issue);
     return bits.join("; ");
   }
-  return `Task #${input.task.id} ${input.transition}: ${input.task.title}`;
+  const needed = taskNotificationNeeded(input);
+  return `Task #${input.task.id} ${input.transition}: ${input.task.title}${issue ? ` (${issue})` : ""}${needed ? `\nNeeded: ${needed}` : ""}`;
+}
+
+function taskNotificationNeeded(input: TaskSemanticNotificationInput): string {
+  if (input.transition === "needs-decision") return "coordinator decision";
+  if (input.transition === "blocked") return blockedReason(input.task) ?? "unblock the worker";
+  if (input.transition === "gate-failed") return gateFailureReason(input.outcome) ?? "inspect failed gate";
+  if (input.transition === "review-requested") return "review requested";
+  if (input.transition === "land-conflict") return "land conflict needs resolution";
+  return "";
+}
+
+function blockedReason(task: Task): string | undefined {
+  const blockers = task.blockedBy ?? [];
+  if (blockers.length === 0) return undefined;
+  return blockers
+    .map((blocker) => [blocker.type, blocker.ref, blocker.note].filter(Boolean).join(": "))
+    .join("; ");
+}
+
+function gateFailureReason(outcome: Record<string, unknown> | undefined): string | undefined {
+  const gate = typeof outcome?.gate === "string" ? outcome.gate : undefined;
+  const detail = typeof outcome?.detail === "string" ? outcome.detail : undefined;
+  if (gate && detail) return `${gate} failed: ${detail}`;
+  if (gate) return `${gate} failed`;
+  return detail;
+}
+
+function primaryIssue(task: Task): StatusPulseDigestItem["issue"] | undefined {
+  const issues = (task as Partial<TaskDetail>).issues;
+  const issue = Array.isArray(issues) ? issues[0] : undefined;
+  if (!issue) return undefined;
+  return {
+    provider: issue.provider,
+    repo: issue.repo,
+    externalKey: issue.externalKey,
+    url: issue.url,
+    ...(issue.title ? { title: issue.title } : {}),
+  };
+}
+
+function issueLabel(issue: StatusPulseDigestItem["issue"] | undefined): string {
+  if (!issue) return "";
+  return `${issue.repo}#${issue.externalKey}`;
 }