agent-relay-server 0.91.4 → 0.93.0

package/src/branch-landed.ts

@@ -1,8 +1,7 @@
 import { errMessage } from "agent-relay-sdk";
 import { emitRelayEvent } from "./events";
-import { getNotificationsConfig } from "./config-store";
 import { routeNotification, INFORMATIONAL_TTL_MS } from "./notification-router";
-import { registerDefaultAudienceRules, resolveAudience, audiencePredicates } from "./notification-rules";
+import { registerDefaultAudienceRules, audiencePredicates } from "./notification-rules";
 import { createActivityEvent, getAgent, updateWorkspaceStatus } from "./db";
 import { handleLandedIssueLifecycle } from "./services/issue-lifecycle";
 import type { WorkspaceMergePreview, WorkspaceRecord } from "./types";
@@ -135,9 +134,6 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
     console.warn(`issue lifecycle land hook failed for ${workspace.id}: ${errMessage(error)}`);
   });
 
-  const config = getNotificationsConfig();
-  if (!config.enabled || !config.branchLanded) return;
-
   const author = workspace.ownerAgentId;
   const shaLabel = shortSha ? ` as \`${shortSha}\`` : "";
   const subjectLabel = input.subject ? ` — "${input.subject}"` : "";
@@ -186,25 +182,22 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
   // online agents whose cwd is the main checkout, author-excluded, team-scoped. Empty for a solo
   // land with no other main agents → no-op.
   const mainScope = { author, repoRoot: workspace.repoRoot, workspaceId: workspace.id, teamId: author ? getAgent(author)?.teamId : undefined };
-  const mainRecipients = resolveAudience("branch.landed", mainScope).map((member) => member.agentId);
-  if (mainRecipients.length > 0) {
-    const branchLabel = landedBranch ? `\`${landedBranch}\`` : "A branch";
-    const authorLabel = author ? ` by \`${author}\`` : "";
-    // Bystander fan-out (ttl informational): a "merged" notice is only useful while fresh — a
-    // late-joining main agent shouldn't be woken by an hours-old land.
-    routeNotification({
-      type: "branch.landed",
-      scope: mainScope,
-      recipients: mainRecipients,
-      ttlMs: INFORMATIONAL_TTL_MS,
-      message: {
-        subject: `Merged to ${base}`,
-        body: `🔀 ${branchLabel}${authorLabel} merged to \`${base}\`${shaLabel}${subjectLabel}.${publishLabel}`,
-        payload: { ...payload, notification: "landed-success" },
-        replyExpected: false,
-      },
-    });
-  }
+  const branchLabel = landedBranch ? `\`${landedBranch}\`` : "A branch";
+  const authorLabel = author ? ` by \`${author}\`` : "";
+  // Bystander fan-out (ttl informational): a "merged" notice is only useful while fresh — a
+  // late-joining main agent shouldn't be woken by an hours-old land. Omit explicit recipients so
+  // the notification router records the full #442 rule decision for #446's routed-because trace.
+  routeNotification({
+    type: "branch.landed",
+    scope: mainScope,
+    ttlMs: INFORMATIONAL_TTL_MS,
+    message: {
+      subject: `Merged to ${base}`,
+      body: `🔀 ${branchLabel}${authorLabel} merged to \`${base}\`${shaLabel}${subjectLabel}.${publishLabel}`,
+      payload: { ...payload, notification: "landed-success" },
+      replyExpected: false,
+    },
+  });
 }
 
 /**
@@ -240,8 +233,6 @@ export function notifyBranchLandFailed(input: {
   });
 
   if (!author) return;
-  const config = getNotificationsConfig();
-  if (!config.enabled || !config.branchLanded) return;
   const branchLabel = workspace.branch ? `\`${workspace.branch}\`` : "Your branch";
   routeNotification({
     type: "landed-failure",
@@ -298,9 +289,6 @@ export function notifyStewardHandoff(input: {
 
   emitRelayEvent({ type: "workspace.steward_handoff", source: "server", subject: workspace.id, data: payload });
 
-  const config = getNotificationsConfig();
-  if (!config.enabled) return;
-
   // #641 — tell the owner branch agent which steward now holds its merge, so it stops
   // thinking the branch silently failed. Durable (ttl null): the owner must learn this
   // even if it went idle. Mirror the "don't touch main" guardrail of the landed-failure wake.

package/src/bus.ts

@@ -5,7 +5,6 @@ import { projectAgentStatusData } from "./agent-card-projection";
 import { emitRelayEvent, subscribeRelayEvents, type RelayEvent } from "./events";
 import { getCommand, updateCommand } from "./commands-db";
 import { emitCommandEvent } from "./command-events";
-import { getLifecycleManager } from "./lifecycle-manager";
 import { noteAgentTimelineEvent, noteCompactionCommandCompleted } from "./compaction-watch";
 import { reconcileTerminalProviderExit } from "./services/terminal-provider-exit";
 import { registerAgent } from "./services/register-agent";
@@ -14,6 +13,8 @@ import { commandAuthorizationResource, dispatchCommand } from "./services/dispat
 import { auditProviderStateTransition } from "./services/provider-state-audit";
 import { ServiceAuthError } from "./services/errors";
 import { ShutdownAuthError, ShutdownTargetError, shutdownAgent, shutdownInputFromBusFrame } from "./services/shutdown-agent";
+import { flushQueuedDirectMessages } from "./services/managed-running";
+import { isAgentUnavailable } from "./db/agent-predicates";
 import { applyCommandToRecipe } from "./recipe-runner";
 import { enqueueContinuationInjectionAfterSelfResume } from "./self-resume";
 import { messageMatchesAgent, targetMatchesAgent } from "./agent-ref";
@@ -121,7 +122,6 @@ export function expireStaleBusAgents(graceMs = busStaleGraceMs()): { agentIds: s
     revokeRuntimeTokensForAgent(row.id, Date.now(), "stale");
     setStatus(row.id, "offline");
     emitAgentStatusEvent(row.id);
-    getLifecycleManager().onAgentDisappeared(row.id);
     const tasks = orphanTasksForAgent(row.id);
     for (const task of tasks) {
       orphanedTasks.push(task);
@@ -152,10 +152,16 @@ function handleFrame(ws: BusWebSocket, frame: ReturnType<typeof validateClientFr
           const current = getAgent(conn.agentId);
           const heldOffline = current?.status === "offline" && isRecord(current.meta?.terminalProviderExit);
           if (!heldOffline) {
+            const wasUnavailable = current ? isAgentUnavailable(current) : false;
             const runtime = runtimeFromMeta(frame.payload.meta);
             heartbeat(conn.agentId, { instanceId: conn.instanceId, epoch: conn.epoch }, runtime);
             if (frame.payload.status) setStatus(conn.agentId, frame.payload.status, { instanceId: conn.instanceId, epoch: conn.epoch });
             emitAgentStatusEvent(conn.agentId);
+            // #416 — flush queued messages if the agent transitioned from unavailable to available.
+            if (wasUnavailable) {
+              const after = getAgent(conn.agentId);
+              if (after && !isAgentUnavailable(after)) flushQueuedDirectMessages(conn.agentId);
+            }
           }
         }
         if (frame.id) send(ws, { type: "ack", payload: { frameId: frame.id } });
@@ -652,6 +658,7 @@ function isContextLifecycleState(value: unknown): value is ContextState["lifecyc
     value === "working" ||
     value === "cooling" ||
     value === "compacting" ||
+    value === "clearing-context" ||
     value === "hibernating";
 }
 

package/src/config-store.ts

@@ -1,7 +1,13 @@
 import { getDb, ValidationError } from "./db";
 import { cleanEnum, cleanString, cleanStringArray } from "./validation";
-import { DEFAULT_CONTEXT_THRESHOLD_CONFIG, validateContextThresholdConfig } from "./context-threshold-config";
-import { DEFAULT_QUOTA_THRESHOLD_CONFIG, validateQuotaThresholdConfig } from "./quota-threshold-config";
+import {
+  NOTIFICATIONS_CONFIG_DEFAULTS,
+  NOTIFICATIONS_DEFAULT_KEY,
+  NOTIFICATIONS_NAMESPACE,
+  parseNotificationSettingsKey,
+  validateNotificationSettingsLayer,
+  validateNotificationsConfig,
+} from "./notification-settings";
 import { DEFAULT_SELF_RESUME_CONFIG, validateSelfResumeConfig } from "./self-resume-config";
 import { TEAM_TEMPLATE_NAMESPACE, validateTeamTemplate } from "./team-template-config";
 import { PROJECT_INSTRUCTION_POLICY_NAMES } from "./project-instructions";
@@ -36,8 +42,6 @@ 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 SELF_RESUME_NAMESPACE = "self-resume";
 const SELF_RESUME_KEY = "default";
 const WORKSPACE_NAMESPACE = "workspace";
@@ -549,26 +553,6 @@ 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, agentReady: true, agentExited: true, agentSpawnFailed: true, contextThreshold: DEFAULT_CONTEXT_THRESHOLD_CONFIG, quotaThreshold: DEFAULT_QUOTA_THRESHOLD_CONFIG };
-
-function validateNotificationsConfig(value: unknown): NotificationsConfig {
-  if (!isRecord(value)) throw new ValidationError("notifications config value must be an object");
-  const bool = (key: "enabled" | "branchLanded" | "agentReady" | "agentExited" | "agentSpawnFailed"): boolean =>
-    value[key] === undefined ? NOTIFICATIONS_CONFIG_DEFAULTS[key] : cleanBoolean(value[key], key);
-  return {
-    enabled: bool("enabled"),
-    branchLanded: bool("branchLanded"),
-    agentReady: bool("agentReady"),
-    agentExited: bool("agentExited"),
-    agentSpawnFailed: bool("agentSpawnFailed"),
-    contextThreshold: validateContextThresholdConfig(value.contextThreshold),
-    quotaThreshold: validateQuotaThresholdConfig(value.quotaThreshold),
-  };
-}
-
 // 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.
@@ -609,7 +593,10 @@ 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 === NOTIFICATIONS_NAMESPACE) {
+    if (!parseNotificationSettingsKey(key)) throw new ValidationError("notifications config key must be default, team:<teamId>, or agent:<agentId>");
+    return key === NOTIFICATIONS_DEFAULT_KEY ? validateNotificationsConfig(value) : validateNotificationSettingsLayer(value);
+  }
   if (namespace === SELF_RESUME_NAMESPACE) return validateSelfResumeConfig(value);
   if (namespace === WORKSPACE_NAMESPACE) return validateWorkspaceConfig(value);
   if (namespace === LANDING_NAMESPACE) return validateLandingConfig(value);
@@ -748,7 +735,7 @@ 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);
+  const entry = getConfig<Partial<NotificationsConfig>>(NOTIFICATIONS_NAMESPACE, NOTIFICATIONS_DEFAULT_KEY);
   if (!entry) return { ...NOTIFICATIONS_CONFIG_DEFAULTS };
   return validateNotificationsConfig({ ...NOTIFICATIONS_CONFIG_DEFAULTS, ...entry.value });
 }

package/src/config.ts

@@ -154,6 +154,7 @@ export const WORKSPACE_REVIEW_TTL_MS = envNumberOrDefault("AGENT_RELAY_WORKSPACE
 export const WORKSPACE_GC_INTERVAL_MS = envNumberOrDefault("AGENT_RELAY_WORKSPACE_GC_INTERVAL_MS", 60 * 60 * 1000);
 export const WORKSPACE_ORPHAN_REAPER_INTERVAL_MS = envNumberOrDefault("AGENT_RELAY_WORKSPACE_ORPHAN_REAPER_INTERVAL_MS", 30 * 60 * 1000);
 export const WORKSPACE_AUTO_MERGE_INTERVAL_MS = envNumberOrDefault("AGENT_RELAY_WORKSPACE_AUTO_MERGE_INTERVAL_MS", CONFLICT_SCAN_INTERVAL_MS);
+export const WORKSPACE_IDLE_REFRESH_INTERVAL_MS = envNumberOrDefault("AGENT_RELAY_WORKSPACE_IDLE_REFRESH_INTERVAL_MS", CONFLICT_SCAN_INTERVAL_MS);
 export const ORPHAN_REAPER_INTERVAL_MS = envNumberOrDefault("AGENT_RELAY_ORPHAN_REAPER_INTERVAL_MS", 5 * 60 * 1000);
 export const STEWARD_WAKE_COOLDOWN_MS = envNumberOrDefault("AGENT_RELAY_STEWARD_WAKE_COOLDOWN_MS", 10 * 60 * 1000);
 export const UNLANDED_FLAG_COOLDOWN_MS = envNumberOrDefault("AGENT_RELAY_ORPHAN_FLAG_COOLDOWN_MS", 6 * 60 * 60 * 1000);

package/src/context-advisory.ts

@@ -1,7 +1,9 @@
 import { deriveContextThresholdFromWindowTokens, findProviderCatalogModel, resolveProviderContextThreshold, type ProviderModelCatalogEntry, type ResolvedProviderContextThreshold } from "agent-relay-sdk/provider-catalog";
 import { isRecord, SPAWN_PROVIDERS } from "agent-relay-sdk";
-import { getConfig, getNotificationsConfig } from "./config-store";
-import { DEFAULT_CONTEXT_THRESHOLD_CONFIG, validateContextThresholdConfig } from "./context-threshold-config";
+import { getConfig } from "./config-store";
+import { validateContextThresholdConfig } from "./context-threshold-config";
+import { getResolvedNotificationsConfig } from "./notification-settings-store";
+import { NOTIFICATIONS_DEFAULT_KEY, NOTIFICATIONS_NAMESPACE, notificationAgentKey, notificationTeamKey } from "./notification-settings";
 import { getDb } from "./db/connection.ts";
 import { emitRelayEvent } from "./events";
 import { routeNotification } from "./notification-router";
@@ -53,9 +55,6 @@ function notifyContextAdvisory(input: ContextAdvisoryInput): void {
     data: payload,
   });
 
-  const config = getNotificationsConfig();
-  if (!config.enabled || !config.contextThreshold.enabled) return;
-
   // Short default TTL (per-type): a stale context advisory is misleading — the band may have moved
   // by the time the agent next polls, so old advice shouldn't wake it.
   routeNotification({
@@ -140,15 +139,14 @@ function effectiveContextThreshold(agent: AgentCard): EffectiveContextThreshold
   if (model?.contextThreshold) {
     return { ...resolveProviderContextThreshold(model), source: "model" };
   }
-  const global = explicitContextThresholdConfig();
+  const global = explicitContextThresholdConfig(agent);
   if (global) return global;
   return { ...deriveContextThresholdFromWindowTokens(windowTokens), source: "window" };
 }
 
-function explicitContextThresholdConfig(): EffectiveContextThreshold | undefined {
-  const entry = getConfig("notifications", "default");
-  if (!entry || !isRecord(entry.value) || !isRecord(entry.value.contextThreshold)) return undefined;
-  const global = validateContextThresholdConfig({ ...DEFAULT_CONTEXT_THRESHOLD_CONFIG, ...entry.value.contextThreshold });
+function explicitContextThresholdConfig(agent: AgentCard): EffectiveContextThreshold | undefined {
+  if (!hasExplicitContextThreshold(agent)) return undefined;
+  const global = validateContextThresholdConfig(getResolvedNotificationsConfig({ agentId: agent.id, teamId: agent.teamId }).contextThreshold);
   const selfCompactUtilization = global.selfCompactUtilization ?? global.advisoryUtilization;
   return {
     selfCompactUtilization,
@@ -158,6 +156,18 @@ function explicitContextThresholdConfig(): EffectiveContextThreshold | undefined
   };
 }
 
+function hasExplicitContextThreshold(agent: AgentCard): boolean {
+  const keys = [
+    NOTIFICATIONS_DEFAULT_KEY,
+    ...(agent.teamId ? [notificationTeamKey(agent.teamId)] : []),
+    notificationAgentKey(agent.id),
+  ];
+  return keys.some((key) => {
+    const entry = getConfig(NOTIFICATIONS_NAMESPACE, key);
+    return isRecord(entry?.value) && isRecord(entry.value.contextThreshold);
+  });
+}
+
 function findAgentCatalogModel(agent: AgentCard, observedWindowTokens: number | undefined): ProviderModelCatalogEntry | undefined {
   const runtime = agent.providerCapabilities?.model;
   const provider = runtime?.provider;

package/src/db/agent-predicates.ts

@@ -1,3 +1,4 @@
+import { isProviderBlocked } from "../provider-state.ts";
 import type { AgentCard } from "../types";
 
 export function isDeliveryAgent(agent: AgentCard): boolean {
@@ -7,3 +8,23 @@ export function isDeliveryAgent(agent: AgentCard): boolean {
     agent.kind !== "channel" &&
     agent.meta?.kind !== "channel";
 }
+
+/**
+ * True when the agent is registered and known to the relay but is currently in a state
+ * where it cannot immediately process new messages: stale (missed heartbeats), provider-
+ * blocked (rate-limited, API error hold), compacting/clearing context, or registered but
+ * not yet ready (starting up).
+ *
+ * Messages sent to an unavailable agent are stored as `delivery_status = 'queued'` and
+ * flushed when the agent transitions back to available (heartbeat, re-registration, or
+ * rate-limit-resume). This is distinct from `status === "offline"` which uses the existing
+ * store-ahead path for unknown/deleted targets.
+ */
+export function isAgentUnavailable(agent: AgentCard): boolean {
+  if (agent.status === "stale") return true;
+  if (isProviderBlocked(agent)) return true;
+  const lcs = agent.context?.lifecycleState;
+  if (lcs === "compacting" || lcs === "clearing-context") return true;
+  if (!agent.ready && agent.status !== "offline") return true;
+  return false;
+}

package/src/db/agents.ts

@@ -395,7 +395,7 @@ export function heartbeat(
       .query(`
         UPDATE agents SET
           last_seen = ?,
-          status = CASE WHEN status = 'offline' THEN 'idle' ELSE status END,
+          status = CASE WHEN status IN ('offline', 'stale') THEN 'idle' ELSE status END,
           provider_capabilities = coalesce(?, provider_capabilities),
           context_state = coalesce(?, context_state),
           quota_state = coalesce(?, quota_state)
@@ -412,7 +412,7 @@ export function heartbeat(
     return result.changes > 0;
   }
   const result = getDb()
-    .query("UPDATE agents SET last_seen = ?, status = CASE WHEN status = 'offline' THEN 'idle' ELSE status END WHERE id = ?")
+    .query("UPDATE agents SET last_seen = ?, status = CASE WHEN status IN ('offline', 'stale') THEN 'idle' ELSE status END WHERE id = ?")
     .run(now, id);
   return result.changes > 0;
 }
@@ -495,7 +495,7 @@ export function reapStaleAgents(ttlMs: number = STALE_TTL_MS): string[] {
   getDb().query("UPDATE agents SET last_seen = ? WHERE id IN ('user', 'system')").run(now);
   const rows = getDb()
     .query(
-      "UPDATE agents SET status = 'offline', ready = 0 WHERE status NOT IN ('offline', 'stale') AND last_seen < ? AND id NOT IN ('user', 'system') RETURNING id"
+      "UPDATE agents SET status = 'stale', ready = 0 WHERE status NOT IN ('offline', 'stale') AND last_seen < ? AND id NOT IN ('user', 'system') RETURNING id"
     )
     .all(cutoff) as any[];
   for (const row of rows) {

package/src/db/delivery.ts

@@ -413,6 +413,44 @@ export function resolveQueuedPolicyMessages(policyName: string, agentId: string)
   return ids.map((id) => getMessage(id)).filter((message): message is Message => Boolean(message));
 }
 
+/**
+ * Flush queued messages addressed directly to `agentId` (not via a policy target): transition
+ * their `delivery_status` from `queued` to `pending` and stamp `resolved_to_agent` so the agent
+ * picks them up on its next poll. Ordered by `queued_at ASC, id ASC` (FIFO). Parallel to
+ * `resolveQueuedPolicyMessages`, which handles `policy:xxx` targets.
+ *
+ * Returns the flushed messages so callers can emit `message.available` / `message.new` /
+ * `message.delivery_updated` events.
+ */
+export function resolveQueuedDirectMessages(agentId: string): Message[] {
+  const rows = getDb().query(`
+    SELECT m.id
+    FROM messages m
+    WHERE m.to_target = ?
+      AND m.delivery_status = 'queued'
+    ORDER BY COALESCE(m.queued_at, m.created_at) ASC, m.id ASC
+  `).all(agentId) as Array<{ id: number }>;
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.id);
+  const placeholders = ids.map(() => "?").join(",");
+  const now = Date.now();
+  getDb().query(`
+    UPDATE messages
+    SET delivery_status = 'pending',
+        resolved_to_agent = ?,
+        delivery_attempts = delivery_attempts + 1,
+        delivery_last_error = NULL,
+        delivery_next_retry_at = NULL,
+        delivery_poison_reason = NULL,
+        delivery_updated_at = ?
+    WHERE id IN (${placeholders})
+  `).run(agentId, now, ...ids);
+  for (const id of ids) {
+    insertMessageDeliveryAttempt(id, { agentId, status: "pending" }, now);
+  }
+  return ids.map((id) => getMessage(id)).filter((message): message is Message => Boolean(message));
+}
+
 export function expireQueuedMessages(now: number = Date.now()): Message[] {
   const rows = getDb().query(`
     SELECT id FROM messages

package/src/db/messages.ts

@@ -19,6 +19,7 @@ import { getAgent, validateAgentSession } from "./agents.ts";
 import { cleanAttachmentRefs, linkAttachmentRefs, validateAttachmentRefs } from "./artifacts.ts";
 import { ClaimError, ValidationError, getDb } from "./connection.ts";
 import { enforceQueueLimit, isChannelAgentId, matchingDeliveryAgents } from "./delivery.ts";
+import { isAgentUnavailable } from "./agent-predicates.ts";
 import { MSG_SELECT, normalizeReactionEmoji, rowToMessage } from "./mappers.ts";
 import { claimMessageRow } from "./message-claims.ts";
 import { getMessage } from "./message-queries.ts";
@@ -469,6 +470,19 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
       queuedAt = now;
       maxAgeSeconds = maxAgeSeconds ?? 86_400;
     }
+  } else if (!isFanoutTarget(input.to) && !isMechanicalMessageKind(input.kind)) {
+    // #416 — queue messages to a registered-but-temporarily-unavailable direct target so they
+    // are not silently held as "pending" while the agent cannot process them. The flush fires
+    // when the agent returns to available (heartbeat stale→idle, re-registration, rate-limit
+    // resume). Offline agents use the existing store-ahead path (policyName is null, status
+    // "offline" → resolveQueuedDirectMessages is never called for them — the queue is cleared
+    // only when the agent actually comes back as non-offline).
+    const directAgent = getAgent(input.to);
+    if (directAgent && isAgentUnavailable(directAgent)) {
+      deliveryStatus = "queued";
+      queuedAt = now;
+      maxAgeSeconds = maxAgeSeconds ?? 86_400;
+    }
   }
 
   // #451/#461 — moderate default TTL for non-claimable FAN-OUT messages the sender didn't bound,
@@ -509,7 +523,10 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
     const newId = Number(result.lastInsertRowid);
     if (threadId === null) setSelfThread.run(newId, newId);
     linkAttachmentRefs("message", newId, attachmentRefs, input.from);
-    if (policyName && deliveryStatus === "queued") enforceQueueLimit(`policy:${policyName}`);
+    if (deliveryStatus === "queued") {
+      if (policyName) enforceQueueLimit(`policy:${policyName}`);
+      else enforceQueueLimit(input.to);
+    }
     return newId;
   })();
 

package/src/db/migrations.ts

@@ -896,9 +896,13 @@ export function applyMigrations(): void {
       next_run_at INTEGER NOT NULL,
       schedule_kind TEXT NOT NULL,
       schedule_def TEXT NOT NULL,
+      message_kind TEXT,
+      channel TEXT,
       subject TEXT,
       body TEXT NOT NULL,
+      claimable INTEGER NOT NULL DEFAULT 0,
       payload TEXT NOT NULL DEFAULT '{}',
+      meta TEXT NOT NULL DEFAULT '{}',
       enabled INTEGER NOT NULL DEFAULT 1,
       run_count INTEGER NOT NULL DEFAULT 0,
       max_runs INTEGER,
@@ -913,6 +917,19 @@ export function applyMigrations(): void {
       claim_expires_at INTEGER
     )
   `);
+  const scheduledTimerCols = (getDb().query("PRAGMA table_info(scheduled_timers)").all() as any[]).map((c: any) => c.name);
+  if (!scheduledTimerCols.includes("message_kind")) {
+    getDb().run("ALTER TABLE scheduled_timers ADD COLUMN message_kind TEXT");
+  }
+  if (!scheduledTimerCols.includes("channel")) {
+    getDb().run("ALTER TABLE scheduled_timers ADD COLUMN channel TEXT");
+  }
+  if (!scheduledTimerCols.includes("claimable")) {
+    getDb().run("ALTER TABLE scheduled_timers ADD COLUMN claimable INTEGER NOT NULL DEFAULT 0");
+  }
+  if (!scheduledTimerCols.includes("meta")) {
+    getDb().run("ALTER TABLE scheduled_timers ADD COLUMN meta TEXT NOT NULL DEFAULT '{}'");
+  }
   getDb().run("CREATE INDEX IF NOT EXISTS idx_scheduled_timers_due ON scheduled_timers(enabled, next_run_at, claim_expires_at)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_scheduled_timers_creator ON scheduled_timers(created_by, enabled, next_run_at)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_scheduled_timers_correlation ON scheduled_timers(correlation_id)");

package/src/db/scheduled-timers.ts

@@ -22,9 +22,13 @@ export interface ScheduledTimer {
   nextRunAt: number;
   scheduleKind: TimerScheduleKind;
   scheduleDef: TimerScheduleDef;
+  messageKind?: string;
+  channel?: string;
   subject?: string;
   body: string;
+  claimable?: boolean;
   payload: Record<string, unknown>;
+  meta: Record<string, unknown>;
   enabled: boolean;
   runCount: number;
   maxRuns?: number;
@@ -51,9 +55,13 @@ interface ScheduledTimerRow {
   next_run_at: number;
   schedule_kind: string;
   schedule_def: string;
+  message_kind: string | null;
+  channel: string | null;
   subject: string | null;
   body: string;
+  claimable: number | null;
   payload: string;
+  meta: string | null;
   enabled: number;
   run_count: number;
   max_runs: number | null;
@@ -78,9 +86,13 @@ export interface CreateScheduledTimerRowInput {
   nextRunAt: number;
   scheduleKind: TimerScheduleKind;
   scheduleDef: TimerScheduleDef;
+  messageKind?: string;
+  channel?: string;
   subject?: string;
   body: string;
+  claimable?: boolean;
   payload?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
   maxRuns?: number;
   expiresAt?: number;
   idempotencyKey?: string;
@@ -92,10 +104,10 @@ export function insertScheduledTimer(input: CreateScheduledTimerRowInput, now =
   getDb().query(`
     INSERT INTO scheduled_timers (
       id, target, created_by, created_by_kind, created_by_scopes, created_by_constraints, delivery_from,
-      created_at, next_run_at, schedule_kind, schedule_def, subject, body, payload, enabled,
+      created_at, next_run_at, schedule_kind, schedule_def, message_kind, channel, subject, body, claimable, payload, meta, enabled,
       run_count, max_runs, expires_at, idempotency_key, correlation_id
     )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 0, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 0, ?, ?, ?, ?)
   `).run(
     id,
     input.target,
@@ -108,9 +120,13 @@ export function insertScheduledTimer(input: CreateScheduledTimerRowInput, now =
     input.nextRunAt,
     input.scheduleKind,
     JSON.stringify(input.scheduleDef),
+    input.messageKind ?? null,
+    input.channel ?? null,
     input.subject ?? null,
     input.body,
+    input.claimable ? 1 : 0,
     JSON.stringify(input.payload ?? {}),
+    JSON.stringify(input.meta ?? {}),
     input.maxRuns ?? null,
     input.expiresAt ?? null,
     input.idempotencyKey ?? null,
@@ -199,20 +215,20 @@ export function completeScheduledTimerRun(input: {
         claimed_by = NULL,
         claim_expires_at = NULL
     WHERE id = ?
-  `).run(runCount, input.now, input.messageId, candidateNextRunAt, enabled ? 1 : 0, input.timer.id);
+      AND claimed_by = ?
+      AND enabled = 1
+  `).run(runCount, input.now, input.messageId, candidateNextRunAt, enabled ? 1 : 0, input.timer.id, input.timer.claimedBy ?? "");
   return getScheduledTimer(input.timer.id)!;
 }
 
 export function recordScheduledTimerFailure(input: {
-  id: string;
+  timer: ScheduledTimer;
   error: string;
   now: number;
   retryMs: number;
   maxFailures: number;
 }): ScheduledTimer | null {
-  const current = getScheduledTimer(input.id);
-  if (!current) return null;
-  const failures = current.consecutiveFailures + 1;
+  const failures = input.timer.consecutiveFailures + 1;
   const enabled = failures < input.maxFailures;
   getDb().query(`
     UPDATE scheduled_timers
@@ -223,17 +239,18 @@ export function recordScheduledTimerFailure(input: {
         claimed_by = NULL,
         claim_expires_at = NULL
     WHERE id = ?
-  `).run(input.error, failures, input.now + input.retryMs, enabled ? 1 : 0, input.id);
-  return getScheduledTimer(input.id);
+      AND claimed_by = ?
+      AND enabled = 1
+  `).run(input.error, failures, input.now + input.retryMs, enabled ? 1 : 0, input.timer.id, input.timer.claimedBy ?? "");
+  return getScheduledTimer(input.timer.id);
 }
 
-export function cancelScheduledTimer(id: string, now = Date.now()): ScheduledTimer | null {
-  const result = getDb().query(`
+export function cancelScheduledTimer(id: string): ScheduledTimer | null {
+  getDb().query(`
     UPDATE scheduled_timers
     SET enabled = 0, claimed_by = NULL, claim_expires_at = NULL, last_error = COALESCE(last_error, 'cancelled')
     WHERE id = ? AND enabled = 1
   `).run(id);
-  if (result.changes === 0) return getScheduledTimer(id);
   return getScheduledTimer(id);
 }
 
@@ -259,9 +276,13 @@ function rowToTimer(row: ScheduledTimerRow): ScheduledTimer {
     nextRunAt: row.next_run_at,
     scheduleKind: row.schedule_kind === "interval" ? "interval" : "once",
     scheduleDef: parseRecord(row.schedule_def) as TimerScheduleDef,
+    messageKind: row.message_kind ?? undefined,
+    channel: row.channel ?? undefined,
     subject: row.subject ?? undefined,
     body: row.body,
+    claimable: row.claimable === 1 ? true : undefined,
     payload: parseRecord(row.payload) ?? {},
+    meta: parseRecord(row.meta) ?? {},
     enabled: row.enabled === 1,
     runCount: row.run_count,
     maxRuns: row.max_runs ?? undefined,

package/src/db/schema.ts

@@ -176,9 +176,13 @@ export function initDb(path: string = "agent-relay.db"): Database {
       next_run_at INTEGER NOT NULL,
       schedule_kind TEXT NOT NULL,
       schedule_def TEXT NOT NULL,
+      message_kind TEXT,
+      channel TEXT,
       subject TEXT,
       body TEXT NOT NULL,
+      claimable INTEGER NOT NULL DEFAULT 0,
       payload TEXT NOT NULL DEFAULT '{}',
+      meta TEXT NOT NULL DEFAULT '{}',
       enabled INTEGER NOT NULL DEFAULT 1,
       run_count INTEGER NOT NULL DEFAULT 0,
       max_runs INTEGER,