agent-relay-server 0.120.5 → 0.121.0

package/src/mcp-task-tools.ts

@@ -88,6 +88,7 @@ export const TASK_TOOLS = [
         teamId: { type: "string" },
         projectId: { type: "string" },
         repo: { type: "string", description: "owner/repo for the task's project/repository" },
+        branch: { type: "string", description: "optional branch ref to seed on the task" },
         dispatch: DISPATCH_SCHEMA,
         issueRefs: { type: "array", items: { type: "string" }, description: "#n, owner/repo#n, GitHub URL, or issue_<id>" },
         defaultRepo: { type: "string", description: "owner/repo for bare #n issue refs" },
@@ -140,14 +141,12 @@ export function relayTaskTool(auth: McpAuthLike, name: string, args: Record<stri
       teamId: cleanString(args.teamId, "teamId", { max: 200 }),
       projectId: cleanString(args.projectId, "projectId", { max: 120 }),
       repo: cleanString(args.repo, "repo", { max: 500 }),
+      branch: cleanString(args.branch, "branch", { max: 500 }),
       dispatch: args.dispatch as TaskDispatch | undefined,
+      issueRefs: Array.isArray(args.issueRefs) ? args.issueRefs.filter((ref): ref is string => typeof ref === "string") : undefined,
+      defaultRepo: cleanString(args.defaultRepo, "defaultRepo", { max: 500 }),
       createdBy: actor,
     });
-    if (Array.isArray(args.issueRefs)) {
-      for (const ref of args.issueRefs) {
-        if (typeof ref === "string" && ref.trim()) addTaskEntityRef(created.id, { issue: ref, defaultRepo: cleanString(args.defaultRepo, "defaultRepo", { max: 500 }), actor });
-      }
-    }
     if (Array.isArray(args.dependsOn)) {
       for (const dep of args.dependsOn) addTaskEntityDependency(created.id, taskIdArg(dep), actor);
     }

package/src/retention-config-store.ts

@@ -0,0 +1,32 @@
+import { getConfig, setConfig } from "./config-store";
+import {
+  RETENTION_CONFIG_DEFAULTS,
+  RETENTION_KEY,
+  RETENTION_NAMESPACE,
+  validateRetentionConfig,
+  type RetentionConfig,
+} from "./retention-config";
+import type { ConfigEntry } from "./types";
+
+/** Instance-wide retention config, merged over defaults (always returns a usable value). */
+export function getRetentionConfig(): RetentionConfig {
+  const entry = getConfig<Partial<RetentionConfig>>(RETENTION_NAMESPACE, RETENTION_KEY);
+  if (!entry) return { ...RETENTION_CONFIG_DEFAULTS };
+  return validateRetentionConfig({ ...RETENTION_CONFIG_DEFAULTS, ...entry.value });
+}
+
+export function getRetentionConfigEntry(): ConfigEntry<RetentionConfig> {
+  const entry = getConfig<RetentionConfig>(RETENTION_NAMESPACE, RETENTION_KEY);
+  return entry ?? {
+    namespace: RETENTION_NAMESPACE,
+    key: RETENTION_KEY,
+    value: { ...RETENTION_CONFIG_DEFAULTS },
+    version: 0,
+    updatedAt: "default",
+    updatedBy: "system",
+  };
+}
+
+export function setRetentionConfig(value: unknown, updatedBy?: string): ConfigEntry<RetentionConfig> {
+  return setConfig(RETENTION_NAMESPACE, RETENTION_KEY, value as RetentionConfig, updatedBy);
+}

package/src/retention-config.ts

@@ -0,0 +1,58 @@
+import { isRecord } from "agent-relay-sdk";
+import { ValidationError } from "./db/connection.ts";
+
+export const RETENTION_NAMESPACE = "retention";
+export const RETENTION_KEY = "default";
+
+export interface RetentionConfig {
+  messageRetentionDays: number;
+  activityEventRetentionDays: number;
+  activityEventMaxRows: number;
+  spawnCommandTerminalRetentionDays: number;
+  pruneBatchSize: number;
+}
+
+export const RETENTION_CONFIG_DEFAULTS: RetentionConfig = {
+  messageRetentionDays: 30,
+  activityEventRetentionDays: 14,
+  activityEventMaxRows: 100_000,
+  spawnCommandTerminalRetentionDays: 14,
+  pruneBatchSize: 10_000,
+};
+
+export const RETENTION_CONFIG_SCHEMA = {
+  type: "object",
+  properties: {
+    messageRetentionDays: { type: "integer", minimum: 1, maximum: 3650 },
+    activityEventRetentionDays: { type: "integer", minimum: 1, maximum: 3650 },
+    activityEventMaxRows: { type: "integer", minimum: 1, maximum: 10_000_000 },
+    spawnCommandTerminalRetentionDays: { type: "integer", minimum: 1, maximum: 3650 },
+    pruneBatchSize: { type: "integer", minimum: 1, maximum: 50_000 },
+  },
+  additionalProperties: false,
+} as const;
+
+function cleanInteger(value: unknown, field: string, fallback: number, min: number, max: number): number {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+    throw new ValidationError(`${field} must be an integer between ${min} and ${max}`);
+  }
+  return value;
+}
+
+export function validateRetentionConfig(value: unknown): RetentionConfig {
+  if (!isRecord(value)) throw new ValidationError("retention config value must be an object");
+  return {
+    messageRetentionDays: cleanInteger(value.messageRetentionDays, "messageRetentionDays", RETENTION_CONFIG_DEFAULTS.messageRetentionDays, 1, 3650),
+    activityEventRetentionDays: cleanInteger(value.activityEventRetentionDays, "activityEventRetentionDays", RETENTION_CONFIG_DEFAULTS.activityEventRetentionDays, 1, 3650),
+    activityEventMaxRows: cleanInteger(value.activityEventMaxRows, "activityEventMaxRows", RETENTION_CONFIG_DEFAULTS.activityEventMaxRows, 1, 10_000_000),
+    spawnCommandTerminalRetentionDays: cleanInteger(
+      value.spawnCommandTerminalRetentionDays,
+      "spawnCommandTerminalRetentionDays",
+      RETENTION_CONFIG_DEFAULTS.spawnCommandTerminalRetentionDays,
+      1,
+      3650,
+    ),
+    pruneBatchSize: cleanInteger(value.pruneBatchSize, "pruneBatchSize", RETENTION_CONFIG_DEFAULTS.pruneBatchSize, 1, 50_000),
+  };
+}

package/src/routes/commands.ts

@@ -1,76 +1,28 @@
 // Auto-split from routes.ts (#299). Domain: commands.
 import { VALID_AGENT_ACTIONS, agentControlActionIcon, auditEvent, authorizeRoute, emitCommand, error, json, parseBody, parseQueryInt, type AgentControlAction, type Handler } from "./_shared";
 import { VALID_WORKSPACE_STATUSES, cleanParams, cleanString, optionalEnum } from "../validation";
-import { ValidationError, deleteWorkspace, getOrchestrator, getWorkspace, patchWorkspaceMetadata, releaseMergeLease, setOrchestratorUpgradeState, setWorkspaceBranch, updateWorkspaceStatus } from "../db";
+import { ValidationError, deleteWorkspace, getOrchestrator, getWorkspace, patchWorkspaceMetadata, setOrchestratorUpgradeState, updateWorkspaceStatus } from "../db";
 import { applyCommandToRecipe } from "../recipe-runner";
-import { claimMetadataPatch } from "../workspace-claim";
 import { clearActiveMemories, injectAlwaysReloadMemories } from "../memory-service";
 import { getCommand, listCommands, updateCommand } from "../commands-db";
 import { emitOrchestratorStatus } from "../sse";
 import { getCompactionWatch } from "../compaction-watch";
-import { isRecord, sanitizeFsName, type LandGateRunResult } from "agent-relay-sdk";
-import { storeTextArtifact } from "../artifact-text";
+import { isRecord } from "agent-relay-sdk";
 import { authContextFromRequest } from "../services/auth-context";
 import { commandAuthorizationResource as dispatchCommandAuthorizationResource, dispatchCommand } from "../services/dispatch-command";
 import { prepareScheduledCommandResultForStorage, settleScheduledCommandTimer } from "../services/scheduler-command";
-import { emitWorkspaceTaskSemanticNotifications } from "../services/task-lifecycle";
 import { ServiceAuthError } from "../services/errors";
-import { notifyBaseWorktreeStrand, notifyBranchLandFailed, notifyBranchLanded, notifyLandGateFailed, notifyLandGateWarnings } from "../branch-landed";
 import { applyIdleRefreshResult } from "../maintenance/workspaces";
 import { seedProviderConfigs } from "../provider-config-store";
 import { notifyAgentSpawnFailed } from "../agent-lifecycle-events";
-import { handleReviewerMergeResult } from "../reviewer-pipeline";
-import { CLEAR_MERGE_NO_PROGRESS, noteMergeNoProgress, scheduleRepoMerge } from "../workspace-auto-merge";
+import { scheduleRepoMerge } from "../workspace-auto-merge";
 import { enqueueContinuationInjectionAfterSelfResume } from "../self-resume";
 import { type Command, type CommandStatus, type CreateCommandInput, type WorkspaceStatus } from "../types";
 import { commandTargetsWorkspaceOwner } from "../workspace-host";
+import { settleWorkspaceCommand } from "../workspace-command-settle";
 
 const VALID_COMMAND_STATUSES = ["pending", "accepted", "running", "succeeded", "failed", "timed_out", "rejected", "canceled"] as const;
 
-// #902 — normalize a land-gate run result that round-tripped through the command bus
-// (JSON, loosely typed) back into a LandGateRunResult. Returns undefined when the value
-// isn't a gate result, so the caller falls back to the generic land-failed path.
-function normalizeGateRunResult(value: unknown): LandGateRunResult | undefined {
-  if (!isRecord(value)) return undefined;
-  const name = typeof value.name === "string" ? value.name : undefined;
-  const command = typeof value.command === "string" ? value.command : "";
-  if (!name) return undefined;
-  return {
-    name,
-    command,
-    optional: value.optional === true,
-    passed: value.passed === true,
-    exitCode: typeof value.exitCode === "number" ? value.exitCode : null,
-    timedOut: value.timedOut === true,
-    durationMs: typeof value.durationMs === "number" ? value.durationMs : 0,
-    outputTail: typeof value.outputTail === "string" ? value.outputTail : "",
-    output: typeof value.output === "string" ? value.output : (typeof value.outputTail === "string" ? value.outputTail : ""),
-  };
-}
-
-function normalizeGateWarnings(value: unknown): LandGateRunResult[] {
-  if (!Array.isArray(value)) return [];
-  return value.map(normalizeGateRunResult).filter((g): g is LandGateRunResult => Boolean(g));
-}
-
-// Upload a gate's full output to a relay artifact; returns its id, or undefined on any
-// failure (artifact upload is best-effort — the tail still rides in the notification).
-async function uploadGateOutputArtifact(workspaceId: string, gate: LandGateRunResult): Promise<string | undefined> {
-  try {
-    const safeName = sanitizeFsName(gate.name, { replacement: "-", maxLen: 60, trimEdge: true, fallback: "gate" });
-    const stored = await storeTextArtifact({
-      text: gate.output || gate.outputTail || "(no output)",
-      filename: `land-gate-${safeName}-${workspaceId}.log`,
-      createdBy: "server",
-      metadata: { kind: "land-gate-output", workspaceId, gateName: gate.name, gateCommand: gate.command, exitCode: gate.exitCode, timedOut: gate.timedOut },
-    });
-    return stored.id;
-  } catch (error) {
-    console.warn(`land-gate artifact upload failed for ${workspaceId} gate "${gate.name}": ${String(error)}`);
-    return undefined;
-  }
-}
-
 function auditCommandOutcome(command: Command): void {
   if (command.status !== "succeeded" && command.status !== "failed") return;
   if (command.type !== "agent.restart" && command.type !== "agent.shutdown" && command.type !== "agent.reconnect") return;
@@ -232,204 +184,15 @@ export const patchCommand: Handler = async (req, params) => {
     if (command.type === "scheduler.command") {
       await settleScheduledCommandTimer(command);
     }
-    if (command.type === "workspace.cleanup" && command.status === "succeeded" && isRecord(command.result)) {
-      const workspaceId = cleanString(command.result.workspaceId, "result.workspaceId", { max: 160 });
-      if (workspaceId) {
-        const workspace = getWorkspace(workspaceId);
-        if (workspace && commandTargetsWorkspaceOwner(command, workspace)) {
-          updateWorkspaceStatus(workspaceId, "cleaned", {
-            cleanupResult: command.result,
-            cleanupCommandId: command.id,
-          });
-        }
-      }
+    const workspaceSettle = settleWorkspaceCommand(command, { onMergeSettled: scheduleRepoMerge });
+    if (workspaceSettle.ignoredWrongOwner) {
+      auditCommandOutcome(command);
+      return json(command);
     }
     if (command.type === "workspace.idle-refresh" && command.status === "succeeded" && isRecord(command.result)) {
       const workspaceId = cleanString(command.result.workspaceId, "result.workspaceId", { max: 160 });
       if (workspaceId) applyIdleRefreshResult(workspaceId, command.result);
     }
-    if (command.type === "workspace.merge") {
-      // Merge settled (either way) — free the per-repo merge lease so the next
-      // base merge can proceed (issue #157).
-      if (command.status === "succeeded" || command.status === "failed") {
-        releaseMergeLease({ commandId: command.id });
-        // #237: the lease just freed — drain the next ready/review_requested row for
-        // this repo right now instead of waiting for the backstop sweep. This is the
-        // on-settle link of the sequential per-repo drain chain (no-op if nothing else
-        // is queued, or if AUTO_MERGE is disabled).
-        const settledRepoRoot = typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined;
-        scheduleRepoMerge(settledRepoRoot);
-      }
-      if (command.status === "succeeded" && isRecord(command.result)) {
-        if (handleReviewerMergeResult(command, command.result)) {
-          emitCommand(command);
-          auditCommandOutcome(command);
-          return json(command);
-        }
-        const workspaceId = cleanString(command.result.workspaceId, "result.workspaceId", { max: 160 });
-        const resultStatus = optionalEnum(command.result.status, "result.status", VALID_WORKSPACE_STATUSES) as WorkspaceStatus | undefined;
-        if (workspaceId && resultStatus) {
-          // Snapshot the row BEFORE the recycle repoints `branch` (#206) — the landed
-          // branch name + author (#239 branch.landed push) come from this pre-mutation state.
-          const landedWorkspace = getWorkspace(workspaceId);
-          if (landedWorkspace && !commandTargetsWorkspaceOwner(command, landedWorkspace)) {
-            auditCommandOutcome(command);
-            return json(command);
-          }
-          const newBranch = cleanString(command.result.newBranch, "result.newBranch", { max: 240 });
-          const normalizedStatus = command.result.merged === true
-            && !newBranch
-            && ["review_requested", "merge_planned", "conflict"].includes(resultStatus)
-            ? "merged"
-            : resultStatus;
-          updateWorkspaceStatus(workspaceId, normalizedStatus, {
-            mergeResult: command.result,
-            mergeCommandId: command.id,
-            mergedAt: Date.now(),
-            // A merge that settles `succeeded` made genuine progress (land / recycle /
-            // noop-resolve / PR-opened) — clear any prior no-progress back-off so the lane
-            // is attempted normally next time (#638).
-            ...CLEAR_MERGE_NO_PROGRESS,
-            mergeError: undefined,
-            ...(normalizedStatus !== resultStatus ? { mergeStatusNormalizedFrom: resultStatus } : {}),
-            // The land consumes the steward's claim (#208 steward contract / vent
-            // #62): a successful land must release it, or `steward inspect` keeps
-            // showing a stale claim on the recycled workspace and blocks the next
-            // automation. Clearing a null claim (auto-merge path) is a harmless no-op.
-            ...claimMetadataPatch(true),
-          });
-          // Land-and-continue (#206): the worktree was recycled onto a fresh branch.
-          // Repoint the row so the next merge targets the live branch, not the deleted one.
-          const mergedSha = cleanString(command.result.mergedSha, "result.mergedSha", { max: 64 });
-          // base_sha tracks the tip the recycled workspace forks from. On a no-ff land
-          // (#287) that's the merge commit (result.baseSha), not the preserved landed
-          // commit (mergedSha); fall back to mergedSha for older orchestrators.
-          const baseSha = cleanString(command.result.baseSha, "result.baseSha", { max: 64 });
-          if (newBranch) {
-            setWorkspaceBranch(workspaceId, newBranch, baseSha ?? mergedSha);
-          }
-          // #239 — push the author a "your branch landed" notice (no polling). Fires on a
-          // real land; a no-op resolution (#230) merged nothing, so it earns no notice.
-          // #423 — a PR-land RECYCLE is a no-op merge (`merged:false`) but a land DID happen
-          // on the remote: the relay carries that ground truth in `params.prLanded`, so the
-          // notice fires from it with the recycled `newBranch` — full rebase-ff parity.
-          const prLanded = isRecord(command.params.prLanded) ? command.params.prLanded : undefined;
-          // #824 — the land advanced a DIRTY base by ref plumbing and the shared checkout was
-          // left in a MIXED state (HEAD moved, some landed working files didn't). The land
-          // succeeded, but surface the strand LOUDLY so it's reconciled before anything reads/
-          // builds/publishes from the stale checkout — never silently as before.
-          const baseWorktreeSync = isRecord(command.result.baseWorktreeSync) ? command.result.baseWorktreeSync : undefined;
-          if (baseWorktreeSync && baseWorktreeSync.reconciled === false && landedWorkspace) {
-            notifyBaseWorktreeStrand({
-              workspace: landedWorkspace,
-              sync: {
-                reconciled: false,
-                unsyncedPaths: Array.isArray(baseWorktreeSync.unsyncedPaths) ? baseWorktreeSync.unsyncedPaths.filter((p): p is string => typeof p === "string") : undefined,
-                preservedWipPaths: Array.isArray(baseWorktreeSync.preservedWipPaths) ? baseWorktreeSync.preservedWipPaths.filter((p): p is string => typeof p === "string") : undefined,
-                message: typeof baseWorktreeSync.message === "string" ? baseWorktreeSync.message : undefined,
-              },
-            });
-          }
-          if ((command.result.merged === true || prLanded) && landedWorkspace) {
-            notifyBranchLanded({
-              workspace: landedWorkspace,
-              mergedSha: prLanded ? cleanString(prLanded.sha, "params.prLanded.sha", { max: 64 }) ?? mergedSha : mergedSha,
-              subject: prLanded
-                ? cleanString(prLanded.subject, "params.prLanded.subject", { max: 200 })
-                : cleanString(command.result.subject, "result.subject", { max: 200 }),
-              // PR-land subjects carry a trailing `(#PR)` GitHub stamps on the squash — not an
-              // issue. Tell the lifecycle hook so it won't close the PR number as an issue (#482).
-              prLand: Boolean(prLanded),
-              newBranch,
-              pushed: prLanded ? true : typeof command.result.pushed === "boolean" ? command.result.pushed : undefined,
-            });
-          }
-          // #902 — OPTIONAL land gates that failed on a SUCCESSFUL land (merged:true, ref
-          // advanced). Warn the worker (tail + combined-output artifact) without blocking.
-          // Best-effort + isolated so a warn-notify throw can't undo the completed land.
-          const gateWarnings = command.result.merged === true ? normalizeGateWarnings(command.result.gateWarnings) : [];
-          if (gateWarnings.length && landedWorkspace) {
-            const warnWorkspace = landedWorkspace;
-            void (async () => {
-              const combined = gateWarnings.map((g) => `### ${g.name} (${g.command}) — ${g.timedOut ? "timed out" : g.exitCode === null ? "could not run" : `exited ${g.exitCode}`}\n${g.output || g.outputTail || "(no output)"}`).join("\n\n");
-              let artifactId: string | undefined;
-              try {
-                artifactId = (await storeTextArtifact({ text: combined, filename: `land-gate-warnings-${warnWorkspace.id}.log`, createdBy: "server", metadata: { kind: "land-gate-warnings", workspaceId: warnWorkspace.id, gateNames: gateWarnings.map((g) => g.name) } })).id;
-              } catch (error) {
-                console.warn(`land-gate-warnings artifact upload failed for ${warnWorkspace.id}: ${String(error)}`);
-              }
-              try {
-                notifyLandGateWarnings({ workspace: warnWorkspace, warnings: gateWarnings, artifactId });
-              } catch (error) {
-                console.warn(`land-gate-warnings notify threw for ${warnWorkspace.id}: ${String(error)}`);
-              }
-            })();
-          }
-        }
-      } else if (command.status === "failed" && command.correlationId) {
-        // Merge couldn't complete — don't leave it stuck in merge_planned. A no-progress
-        // merge now settles `failed` (orchestrator #638) carrying the result; honor the
-        // orchestrator's intended target status when it gave a valid one so a real
-        // `conflict` routes to the steward (a non-landable status the auto-merge job
-        // skips, which itself stops the loop) rather than bouncing back to the landable
-        // `review_requested`. Surface the error and count the no-progress attempt so the
-        // auto-merge job backs off after N instead of busy-looping (#638).
-        const current = getWorkspace(command.correlationId);
-        if (current && current.status === "merge_planned") {
-          if (!commandTargetsWorkspaceOwner(command, current)) {
-            auditCommandOutcome(command);
-            return json(command);
-          }
-          const failedResultStatus = isRecord(command.result)
-            ? optionalEnum(command.result.status, "result.status", VALID_WORKSPACE_STATUSES) as WorkspaceStatus | undefined
-            : undefined;
-          const nextStatus: WorkspaceStatus = failedResultStatus && failedResultStatus !== "merge_planned"
-            ? failedResultStatus
-            : "review_requested";
-          updateWorkspaceStatus(command.correlationId, nextStatus, {
-            mergeCommandId: command.id,
-            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,
-              },
-            });
-          }
-          const gateFailure = isRecord(command.result) ? normalizeGateRunResult(command.result.gateFailure) : undefined;
-          if (gateFailure) {
-            // #902 — a REQUIRED land gate failed: the orchestrator aborted WITHOUT advancing
-            // the ref and settled status "review_requested" (not "conflict", so the steward
-            // path above is never taken). Send the richer worker+coordinator notice (gate name
-            // + output tail + full-output artifact) INSTEAD of the generic land-failed wake.
-            // Best-effort + isolated: the land already (didn't) happen; a notify/upload throw
-            // must not break command settling.
-            void (async () => {
-              const artifactId = await uploadGateOutputArtifact(current.id, gateFailure);
-              try {
-                notifyLandGateFailed({ workspace: current, gate: gateFailure, artifactId });
-              } catch (error) {
-                console.warn(`land-gate-failed notify threw for ${current.id}: ${String(error)}`);
-              }
-            })();
-          } else {
-            notifyBranchLandFailed({
-              workspace: current,
-              commandId: command.id,
-              reason: command.error ?? "merge failed",
-            });
-          }
-        }
-      }
-    }
     if (command.type === "workspace.reconcile" && command.status === "succeeded" && isRecord(command.result)) {
       const workspaceId = cleanString(command.result.workspaceId, "result.workspaceId", { max: 160 });
       const resultStatus = optionalEnum(command.result.status, "result.status", VALID_WORKSPACE_STATUSES) as WorkspaceStatus | undefined;

package/src/routes/messages.ts

@@ -7,7 +7,7 @@ import { emitMessageClaimed, emitMessageDeleted, emitMessageDeliveryUpdated, emi
 import { errMessage, isMechanicalMessageKind, isRecord } from "agent-relay-sdk";
 import { injectMemoryForMessageDelivery } from "../memory-service";
 import { authContextFromRequest } from "../services/auth-context";
-import { sendMessageService } from "../services/send-message";
+import { sendMessagesBatchService, sendMessageService } from "../services/send-message";
 import { AmbiguousTargetError, ServiceAuthError } from "../services/errors";
 import { type AgentSessionGuard, type Message, type SendMessageInput } from "../types";
 
@@ -73,6 +73,7 @@ function isDirectTarget(to: string): boolean {
 }
 
 const VALID_MSG_KINDS = ["chat", "channel.event", "task", "pair", "control", "system", "session"];
+const MAX_MESSAGE_BATCH = 100;
 
 export const getQueuedMessagesRoute: Handler = (req) => {
   const url = new URL(req.url);
@@ -149,6 +150,17 @@ export const postMessage: Handler = async (req) => {
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   try {
+    if (isRecord(parsed.body) && Array.isArray(parsed.body.messages)) {
+      if (parsed.body.messages.length === 0 || parsed.body.messages.length > MAX_MESSAGE_BATCH) {
+        throw new ValidationError(`messages must contain 1-${MAX_MESSAGE_BATCH} items`);
+      }
+      const inputs = parsed.body.messages.map((message) => normalizeMessageInput(message));
+      if (inputs.some((input) => input.kind !== "session")) {
+        throw new ValidationError("batch messages only supports kind=session");
+      }
+      const results = sendMessagesBatchService(inputs, authContextFromRequest(req));
+      return json({ messages: results.map((result) => result.message) }, 201);
+    }
     const input = normalizeMessageInput(parsed.body);
     if (!input.idempotencyKey) {
       input.idempotencyKey = cleanString(req.headers.get("Idempotency-Key") ?? undefined, "idempotencyKey", { max: 240 });

package/src/routes/tasks.ts

@@ -130,14 +130,12 @@ export const postTaskCreate: Handler = async (req) => {
       teamId: cleanString(body.teamId, "teamId", { max: 200 }),
       projectId: cleanString(body.projectId, "projectId", { max: 120 }),
       repo: cleanString(body.repo, "repo", { max: 500 }),
+      branch: cleanString(body.branch, "branch", { max: 500 }),
       dispatch: body.dispatch as TaskDispatch | undefined,
+      issueRefs: Array.isArray(body.issueRefs) ? body.issueRefs.filter((ref): ref is string => typeof ref === "string") : undefined,
+      defaultRepo: cleanString(body.defaultRepo, "defaultRepo", { max: 500 }),
       createdBy: actorOf(req, body.createdBy),
     });
-    if (Array.isArray(body.issueRefs)) {
-      for (const ref of body.issueRefs) {
-        if (typeof ref === "string" && ref.trim()) addTaskEntityRef(created.id, { issue: ref, defaultRepo: cleanString(body.defaultRepo, "defaultRepo", { max: 500 }), actor: actorOf(req, body.createdBy) });
-      }
-    }
     if (Array.isArray(body.dependsOn)) {
       for (const dep of body.dependsOn) {
         const depId = parseId(String(dep));

package/src/routing-policy-store.ts

@@ -278,7 +278,7 @@ function normalizeProviderQuotaConfig(raw: unknown, provider: string): ProviderQ
   if (!isRecord(raw)) throw new ValidationError(`providerQuota.${provider} must be an object`);
   const cfg: ProviderQuotaRoutingConfig = {};
   if (raw.hardBackstopUtilization !== undefined) {
-    cfg.hardBackstopUtilization = cleanFraction(raw.hardBackstopUtilization, `providerQuota.${provider}.hardBackstopUtilization`);
+    cfg.hardBackstopUtilization = cleanHardBackstopFraction(raw.hardBackstopUtilization);
   }
   if (raw.burnPenaltyUtilizationFloor !== undefined) {
     cfg.burnPenaltyUtilizationFloor = cleanFraction(raw.burnPenaltyUtilizationFloor, `providerQuota.${provider}.burnPenaltyUtilizationFloor`);
@@ -293,6 +293,16 @@ function cleanQuotaFraction(value: unknown, field: string): number {
   return value;
 }
 
+function cleanHardBackstopFraction(value: unknown): number {
+  // hardBackstopUtilization=0 is an intentional contract: disable the hard backstop
+  // for that provider. Other invalid values normalize to the default instead.
+  if (value === 0) return 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    return 0.99;
+  }
+  return value;
+}
+
 function cleanFraction(value: unknown, field: string): number {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
     throw new ValidationError(`${field} must be a number between 0 and 1`);

package/src/server.ts

@@ -13,6 +13,7 @@ import { installNotificationSubscriptionRule } from "./notification-subscription
 import { installQuotaAdvisoryHandler } from "./quota-advisory";
 import { startPlanLiveBindings } from "./services/plan-live-bindings";
 import { startRelayScheduler } from "./services/scheduler";
+import { startEventLoopLagSampler } from "./event-loop-lag";
 import { recordWorkspaceIssueActivity } from "./services/spawn-issue-activity";
 import { onWorkspaceCreate } from "./db";
 import { isTerminalSessionRequestAuthorized } from "./terminal-authz";
@@ -80,6 +81,7 @@ export function startServer(): void {
   getCompactionWatch().start();
   reconcileRelayVersion();
   startConnectorStatusPoller();
+  startEventLoopLagSampler();
   startMaintenanceScheduler();
   startRelayScheduler();
 

package/src/services/issue-lifecycle.ts

@@ -1,5 +1,5 @@
 import { errMessage } from "agent-relay-sdk";
-import { getAgent, listPlansWithBoundOwner, deliverableTaskIdsByBranch } from "../db";
+import { getAgent, listPlansWithBoundOwner, deliverableTaskIdsByBranch, deliverableTaskIdsByOwnerAgent, deliverableTaskIdsBySpawnRequestId } from "../db";
 import { listIssuesForEntity, planNodeIssueEntityId } from "../db/issue-associations";
 import {
   getSuccessfulIssueLifecycleAction,
@@ -142,17 +142,28 @@ function associatedIssueRefs(workspace: LifecycleWorkspace): IssueRef[] {
       }
     }
   }
-  // #834 — task-aware resolution: a deliverable Task owns its branch, so the landed branch
-  // resolves to its linked issue(s). This is the resolution PATH; lifecycle automation that
-  // advances the Task itself on land is #831.
-  if (workspace.branch) {
-    for (const taskId of deliverableTaskIdsByBranch(workspace.branch)) {
-      refs.push(...listIssuesForEntity("task", String(taskId)).map((item) => item.issueRef));
-    }
+  for (const taskId of associatedTaskIds(workspace)) {
+    refs.push(...listIssuesForEntity("task", String(taskId)).map((item) => item.issueRef));
   }
   return issueRefMap(refs);
 }
 
+function associatedTaskIds(workspace: LifecycleWorkspace): number[] {
+  const ids = new Set<number>();
+  const ownerId = workspace.ownerAgentId?.trim();
+  if (ownerId) {
+    for (const id of deliverableTaskIdsByOwnerAgent(ownerId)) ids.add(id);
+    const spawnRequestId = getAgent(ownerId)?.meta?.spawnRequestId;
+    if (typeof spawnRequestId === "string" && spawnRequestId.trim()) {
+      for (const id of deliverableTaskIdsBySpawnRequestId(spawnRequestId)) ids.add(id);
+    }
+  }
+  if (workspace.branch) {
+    for (const id of deliverableTaskIdsByBranch(workspace.branch)) ids.add(id);
+  }
+  return [...ids].sort((a, b) => a - b);
+}
+
 const CLOSING_KEYWORD_RE = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+([^\n\r]+)/gi;
 const ISSUE_REF_AT_START_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 REF_SEPARATOR_RE = /^(?:\s*,\s*|\s+(?:and|&)\s+)/i;
@@ -400,6 +411,10 @@ export async function handleLandedIssueLifecycle(input: LandedIssueLifecycleInpu
 }> {
   if ((input.workspace.baseRef ?? "main") !== "main") return { source: "commit", closed: [], reopened: [], skipped: ["non-default-branch"] };
   const resolved = await resolveIssueRefsForLand(input);
+  const taskIds = associatedTaskIds(input.workspace);
+  if (resolved.refs.length === 0 && taskIds.length > 0) {
+    logFailure(opts, `issue lifecycle found landed task(s) without linked issue refs: tasks=${taskIds.join(",")} workspace=${input.workspace.id} branch=${input.workspace.branch ?? "unknown"}`);
+  }
   const closed: CloseIssueLifecycleResult[] = [];
   for (const ref of resolved.refs) {
     closed.push(await closeIssueRefForLand(ref, resolved.source, input, opts));