agent-relay-server 0.102.1 → 0.103.4

package/src/mcp/tools-spawn.ts

@@ -71,7 +71,7 @@ export const SPAWN_TOOLS: ToolDefinition[] = [
           required: ["branch", "mode"],
           additionalProperties: false,
         },
-        waitForRegistrationMs: { type: "integer", minimum: 0, maximum: 30000, description: "How long to wait for the spawned agent to register before returning, so the response carries its resolved agent id (default 8000; 0 = return immediately with just spawnRequestId)." },
+        waitForRegistrationMs: { type: "integer", minimum: 0, maximum: 30000, description: "How long to wait for the spawned agent to register before returning, so the response carries its resolved agent id (default 0 = fire-and-forget; you will be PUSHED agent.ready when the child is ready)." },
       },
       required: ["provider"],
       additionalProperties: false,
@@ -158,7 +158,7 @@ export async function relaySpawnAgent(auth: McpAuthContext, args: Record<string,
     providerArgs: optionalStringArray(args.providerArgs, "providerArgs"),
     spawnRequestId: optionalString(args.spawnRequestId, "spawnRequestId", 160),
     requestedVia: "mcp",
-    waitForRegistrationMs: optionalNonNegativeInt(args.waitForRegistrationMs, "waitForRegistrationMs") ?? 8000,
+    waitForRegistrationMs: optionalNonNegativeInt(args.waitForRegistrationMs, "waitForRegistrationMs") ?? 0,
     resumeWorkspace: parseResumeWorkspace(args.resumeWorkspace),
   };
   const result = await spawnAgent(input, authContextFromMcp(auth));

package/src/mcp-team-template-tools.ts

@@ -1,4 +1,4 @@
-import { APPROVAL_MODES, VALID_AGENT_LIFECYCLES, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
+import { APPROVAL_MODES, SPAWN_PROVIDERS, VALID_AGENT_LIFECYCLES, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
 import { McpAuthError } from "./mcp-errors";
 import { authContextFromMcp } from "./services/auth-context";
 import { deleteTeamTemplate, getTeamTemplate, instantiateTeamTemplate, listTeamTemplates, saveTeamTemplate } from "./services/team-templates";
@@ -9,7 +9,7 @@ const COMPOSITION_ENTRY_SCHEMA = {
   type: "object",
   properties: {
     label: { type: "string" },
-    provider: { type: "string", enum: ["claude", "codex"] },
+    provider: { type: "string", enum: SPAWN_PROVIDERS },
     model: { type: "string" },
     effort: { type: "string" },
     profile: { type: "string" },

package/src/provider-catalog-store.ts

@@ -138,7 +138,7 @@ export function mergeProviderCatalog(
 }
 
 function normalizeOverrideInput(input: ProviderModelOverrideInput): ProviderModelOverrideInput {
-  if (!SPAWN_PROVIDERS.includes(input.provider)) throw new ValidationError("provider must be claude or codex");
+  if (!SPAWN_PROVIDERS.includes(input.provider)) throw new ValidationError(`provider must be one of: ${SPAWN_PROVIDERS.join(", ")}`);
   const alias = input.alias.trim();
   if (!alias) throw new ValidationError("model alias is required");
   if (input.entry.alias !== alias) throw new ValidationError("model entry alias must match override alias");

package/src/quota-band-transition.ts

@@ -14,17 +14,36 @@
 // at most one per RECOVERY_MIN_INTERVAL_MS — degradation is the actionable
 // signal; fleet-wake on recovery churn is suppressed.
 //
+// #798 — principled noisy-signal → discrete-state pipeline so a provider in a
+// steady state stops re-emitting band-change notifications:
+//   1. LOW-PASS (EMA): the raw penalty/slack jitters tick-to-tick (burnRatio
+//      recompute, shrinking timeToReset). An exponential moving average with a
+//      few-minute time constant is applied to the signal BEFORE it is thresholded
+//      into a band — killing the noise at the source, so a transient single-tick
+//      excursion never reaches the opposite band.
+//   2. SCHMITT (applyHysteresis): enter/exit thresholds with a gap on the band
+//      STATE (not just the routing weight — that's where #756 fell short).
+//   3. MIN-DWELL DEBOUNCE: the new band must hold DEBOUNCE_SAMPLES ticks before
+//      the human-facing notification fires.
+// The idle-projection de-bias + position penalty (db/provider-quota-burn.ts,
+// spawn-targets.ts) attack the same flap from the other end: an idle provider's
+// band is now position-pinned, so the input the pipeline sees is already stable.
+//
 // Called from handleProviderQuotaAdvisory in quota-advisory.ts so the check
 // runs on the same event hook as the utilization-threshold advisory — no
 // parallel delivery channel.
 import { emitRelayEvent } from "./events";
 import { routeNotification } from "./notification-router";
 import { getSpawnCapableAgentIds } from "./routing-policy-push";
-import { getProviderBandInfo, windowRecommendedAction } from "./spawn-targets";
+import { getProviderBandInfo, quotaBandFromSignal, windowRecommendedAction } from "./spawn-targets";
 import type { ProviderBandInfo, ProviderBandWindow, QuotaBand } from "./spawn-targets";
 import type { ProviderQuotaAdvisoryInput } from "./db/provider-quotas";
 
 const DEBOUNCE_SAMPLES = 3;
+// #798 — EMA time constant for the low-pass. "A few minutes": longer than the ~5-min poll-cadence
+// tick jitter (so noise is smoothed), far shorter than the 5h/7d utilization trend (so a genuine
+// quota move still surfaces within a poll or two). dt-based, so it is correct at any cadence.
+const EMA_TAU_MS = 6 * 60_000;
 // Penalty must drop this far below the band entry threshold before recovery is recognised.
 // #760: widened 0.05 → 0.10. Live evidence (Claude 7d parked at avoidLargeAt with burn×1.4)
 // showed the 0.05 deadband was too tight for real penalty jitter — it still ping-ponged
@@ -42,6 +61,22 @@ interface TransitionState {
   pendingBand: QuotaBand | null;
   pendingCount: number;
   lastTransitionAt: number;
+  // #798 — low-pass state: EMA of the noisy penalty/slack signal, plus the tick time it was last
+  // updated (to size the dt-based smoothing factor). null until the first high-confidence sample.
+  emaPenalty: number | null;
+  emaSlack: number | null;
+  emaUpdatedAt: number;
+}
+
+// #798 — dt-based EMA blend factor: 1 − e^(−dt/τ). dt = 0 (or first sample) → seed verbatim.
+function emaAlpha(dtMs: number): number {
+  if (!(dtMs > 0)) return 1;
+  return 1 - Math.exp(-dtMs / EMA_TAU_MS);
+}
+
+function emaStep(prev: number | null, value: number, dtMs: number): number {
+  if (prev === null) return value;
+  return prev + emaAlpha(dtMs) * (value - prev);
 }
 
 const bandState = new Map<string, TransitionState>();
@@ -73,17 +108,33 @@ export function processBandTransitions(input: ProviderQuotaAdvisoryInput): void
       pendingBand: null,
       pendingCount: 0,
       lastTransitionAt: 0,
+      emaPenalty: null,
+      emaSlack: null,
+      emaUpdatedAt: 0,
     };
 
-    // #756: asymmetric hysteresis — recovery needs penalty HYSTERESIS_MARGIN below the entry
-    // threshold of the current band to prevent ping-pong at a boundary. #760 extends this with a
-    // slack deadband for the "prefer" boundary.
-    const effectiveBand = applyHysteresis(window.band, window.penalty, window.slack, state.lastNotifiedBand, info.quotaBands, info.preferSlackAt);
+    // #798 (layer 1) — low-pass the noisy penalty/slack BEFORE thresholding, then re-classify the
+    // smoothed signal into a band. A transient one-tick excursion is averaged out, so it never
+    // reaches (and re-emits) the opposite band; a sustained move still crosses within a poll or two.
+    const dtMs = state.emaUpdatedAt > 0 ? input.now - state.emaUpdatedAt : 0;
+    const emaPenalty = emaStep(state.emaPenalty, window.penalty, dtMs);
+    const emaSlack = window.slack === null ? state.emaSlack : emaStep(state.emaSlack, window.slack, dtMs);
+    state.emaPenalty = emaPenalty;
+    state.emaSlack = emaSlack;
+    state.emaUpdatedAt = input.now;
+    // Persist immediately so the low-pass state survives every early-continue below (the state is
+    // then mutated in place by reference — the EMA must carry across ticks to smooth excursions).
+    bandState.set(key, state);
+    const smoothedBand = quotaBandFromSignal(emaPenalty, emaSlack, info.quotaBands, info.preferSlackAt);
+
+    // #756 (layer 2): asymmetric hysteresis — recovery needs penalty HYSTERESIS_MARGIN below the
+    // entry threshold of the current band to prevent ping-pong at a boundary. #760 extends this with
+    // a slack deadband for the "prefer" boundary. Operates on the smoothed signal.
+    const effectiveBand = applyHysteresis(smoothedBand, emaPenalty, emaSlack, state.lastNotifiedBand, info.quotaBands, info.preferSlackAt);
 
     if (effectiveBand === state.lastNotifiedBand) {
-      if (state.pendingBand !== null) {
-        bandState.set(key, { ...state, pendingBand: null, pendingCount: 0 });
-      }
+      state.pendingBand = null;
+      state.pendingCount = 0;
       continue;
     }
 

package/src/recipe-validator.ts

@@ -1,6 +1,6 @@
 import type { MemoryType, Recipe, RecipeAgent, RecipeMemoryPolicy } from "./types";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { errMessage, isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord, isSpawnProvider, SPAWN_PROVIDERS } from "agent-relay-sdk";
 import { effectiveProviderCatalogList } from "./provider-catalog-store";
 
 class RecipeValidationError extends Error {}
@@ -41,7 +41,9 @@ export function validateRecipe(value: unknown): Recipe {
 function validateAgent(value: unknown): RecipeAgent {
   if (!isRecord(value)) throw new RecipeValidationError("agent must be an object");
   const provider = value.provider;
-  if (provider !== "claude" && provider !== "codex") throw new RecipeValidationError("agent.provider must be claude or codex");
+  if (!isSpawnProvider(provider)) {
+    throw new RecipeValidationError(`agent.provider must be one of: ${SPAWN_PROVIDERS.join(", ")}`);
+  }
   const capabilities = stringArray(value.capabilities, "agent.capabilities");
   if (capabilities.length === 0) throw new RecipeValidationError("agent.capabilities must not be empty");
   const approvalMode = value.approvalMode;

package/src/routes/agent-profiles.ts

@@ -5,7 +5,7 @@ import { deleteAgentProfile, getAgentProfile, listAgentProfiles, setAgentProfile
 import { emitConfigChanged } from "../sse";
 import { error, isRootCredentialRequest, json, normalizeConfigPathParam, parseBody, type Handler } from "./_shared";
 import { getComponentAuth, hasComponentScope } from "../security";
-import { isRecord } from "agent-relay-sdk";
+import { isRecord, isSpawnProvider } from "agent-relay-sdk";
 import { SPAWN_PROVIDERS, type AgentProfile, type SpawnProvider } from "../types";
 
 export const getAgentProfilesRoute: Handler = () => json(listAgentProfiles());
@@ -29,7 +29,7 @@ export const getResolvedAgentProfileRoute: Handler = (req, params) => {
     const entry = getAgentProfile(name);
     if (!entry) return error("agent profile not found", 404);
     const requestedProvider = new URL(req.url).searchParams.get("provider") ?? undefined;
-    const profileProvider = entry.value.provider === "claude" || entry.value.provider === "codex" ? entry.value.provider : undefined;
+    const profileProvider = isSpawnProvider(entry.value.provider) ? entry.value.provider : undefined;
     const provider = optionalEnum(requestedProvider, "provider", SPAWN_PROVIDERS, profileProvider ?? "codex") as SpawnProvider;
     const profile = withResolvedProvisioning(entry.value, provider);
     return profile ? json({ provider, profile }) : error("agent profile not found", 404);

package/src/routes/agent-sessions.ts

@@ -1,5 +1,5 @@
 // Auto-split from routes.ts (#299). Domain: agent-sessions.
-import { RELAY_TOKEN_HEADER, isRecord } from "agent-relay-sdk";
+import { RELAY_TOKEN_HEADER, isRecord, isSpawnProvider } from "agent-relay-sdk";
 import { VALID_AGENT_ACTIONS, agentControlActionIcon, auditEvent, authAuditMetadata, authorizeAgentRoute, authorizeRoute, canViewAgentRoute, cleanAttachmentRefs, dashboardAttribution, emitCommand, error, json, metaString, parseBody, requestUserAddress, requestUserId, spawnRequestId, type AgentControlAction, type Handler } from "./_shared";
 import { arbitrateDrive, currentDriver, drivingMessage, releaseDrive, type DriveArbitration } from "../agent-drive-arbiter";
 import { ValidationError, getAgent, getAgentTimeline, getOrchestrator, markReady, mergeAgentMeta, sendMessage, withResolvedProvisioning } from "../db";
@@ -18,10 +18,9 @@ import { authContextFromRequest } from "../services/auth-context";
 import { ShutdownAuthError, ShutdownTargetError, shutdownAgent } from "../services/shutdown-agent";
 import { type AgentCard, type SpawnApprovalMode } from "../types";
 import { type ProviderEffort } from "agent-relay-sdk/provider-catalog";
+import { getManifest } from "agent-relay-providers";
 import { relayToken } from "../config";
 
-const CLAUDE_RESUME_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
 // 409 when a second human tries to drive an agent another user is already driving (#394). The
 // blocked driver learns who holds the wheel so the UI can show "X is driving" + offer "request".
 function driveBlockedResponse(arb: Extract<DriveArbitration, { allowed: false }>): Response {
@@ -61,7 +60,7 @@ function agentIsControlEligible(agent: AgentCard): boolean {
 
 function agentCanReceiveControlAction(agent: AgentCard, action: AgentControlAction): boolean {
   if (!agentIsControlEligible(agent)) return false;
-  if (action === "resume") return agentRuntimeProvider(agent) === "claude" && (agent.status === "offline" || agent.status === "stale");
+  if (action === "resume") return getManifest(agentRuntimeProvider(agent) ?? "")?.resume?.supported === true && (agent.status === "offline" || agent.status === "stale");
   // Interrupt only makes sense while the provider is mid-turn, and only if the
   // provider advertises it can be interrupted from the dashboard.
   if (action === "interrupt") return agent.providerCapabilities?.liveSession?.interrupt === true && agent.status === "busy";
@@ -109,11 +108,11 @@ function restartSpawnParamsForAgent(
   const requestedBy = opts.resumeId ? "dashboard-resume" : "dashboard-restart";
   if (policy) {
     const params = { ...buildManagedSpawnParams(policy.value, requestId, { createdBy: "managed-agent" }), agentId: agent.id, requestedBy };
-    return opts.resumeId ? withClaudeResumeParams(params, opts.resumeId, agent.id) : params;
+    return opts.resumeId ? withResumeParams(params, opts.resumeId, agent.id) : params;
   }
 
   const provider = metaString(agent.meta, "provider");
-  if (provider !== "claude" && provider !== "codex") return undefined;
+  if (!isSpawnProvider(provider)) return undefined;
   const cwd = metaString(agent.meta, "cwd") ?? orchestrator.baseDir;
   const label = metaString(agent.meta, "label") ?? agent.label;
   const approvalMode = metaString(agent.meta, "approvalMode") as SpawnApprovalMode | undefined;
@@ -155,48 +154,44 @@ function restartSpawnParamsForAgent(
     requestedBy,
     requestedAt: Date.now(),
   });
-  return opts.resumeId ? withClaudeResumeParams(params, opts.resumeId, agent.id) : params;
+  return opts.resumeId ? withResumeParams(params, opts.resumeId, agent.id) : params;
 }
 
 function spawnRequestIdForRestart(): string {
   return generateSpawnRequestId();
 }
 
-function withClaudeResumeParams(params: Record<string, unknown>, resumeId: string, agentId: string): Record<string, unknown> {
+function withResumeParams(params: Record<string, unknown>, resumeId: string, agentId: string): Record<string, unknown> {
   return {
     ...params,
-    providerArgs: providerArgsWithClaudeResume(recordStringArray(params.providerArgs), resumeId),
+    providerArgs: providerArgsWithResume(metaStringArray(params as Record<string, unknown>, "providerArgs"), resumeId),
     resumeOfAgentId: agentId,
     claudeResumeId: resumeId,
   };
 }
 
-function providerArgsWithClaudeResume(args: string[], resumeId: string): string[] {
+function providerArgsWithResume(args: string[], resumeId: string): string[] {
   const cleaned: string[] = [];
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     if (!arg) continue;
-    if (arg === "--resume") {
-      i += 1;
-      continue;
-    }
+    if (arg === "--resume") { i += 1; continue; }
     if (arg.startsWith("--resume=")) continue;
     cleaned.push(arg);
   }
   return [...cleaned, "--resume", resumeId];
 }
 
-function recordStringArray(value: unknown): string[] {
-  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && item.trim().length > 0) : [];
-}
-
-function latestClaudeResumeIdForAgent(agent: AgentCard): string | undefined {
+function latestResumeIdForAgent(agent: AgentCard): string | undefined {
+  const provider = agentRuntimeProvider(agent);
+  const resume = getManifest(provider ?? "")?.resume as { supported: boolean; idPattern?: string } | undefined;
+  if (!provider || !resume?.supported) return undefined;
+  const re = resume.idPattern ? new RegExp(`^${resume.idPattern}$`, "i") : undefined;
   for (const entry of getAgentTimeline(agent.id, { limit: 50 })) {
     const metadata = entry.metadata;
     if (!metadata) continue;
-    const provider = metaString(metadata, "provider");
     const resumeId = metaString(metadata, "claudeResumeId");
-    if (provider === "claude" && resumeId && CLAUDE_RESUME_ID_RE.test(resumeId)) return resumeId;
+    if (metaString(metadata, "provider") === provider && resumeId && (!re || re.test(resumeId))) return resumeId;
   }
   return undefined;
 }
@@ -270,9 +265,9 @@ export const postAgentAction: Handler = async (req, params) => {
     const metaTmuxSession = typeof agent.meta?.tmuxSession === "string" ? agent.meta.tmuxSession : undefined;
     const metaPolicyName = typeof agent.meta?.policyName === "string" ? agent.meta.policyName : undefined;
     const metaSpawnRequestId = typeof agent.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : undefined;
-    const resumeId = action === "resume" ? latestClaudeResumeIdForAgent(agent) : undefined;
+    const resumeId = action === "resume" ? latestResumeIdForAgent(agent) : undefined;
     if (action === "resume" && !orchestrator) return error("no online orchestrator available to resume agent", 409);
-    if (action === "resume" && !resumeId) return error("no Claude resume id recorded for agent", 422);
+    if (action === "resume" && !resumeId) return error("no resume id recorded for agent", 422);
     const denied = authorizeRoute(req, {
       scope: "agent:write",
       resource: { agentId: agent.id, orchestratorId: orchestrator?.id, policyName: metaPolicyName, spawnRequestId: metaSpawnRequestId },

package/src/routes/provider-config.ts

@@ -29,7 +29,7 @@ export const getProviderConfigsRoute: Handler = (req) => {
   migrateLocalProviderConfigs();
   const entries = listProviderConfigEntries(host);
   return json(Object.fromEntries(VALID_PROVIDER_CONFIGS.map((provider) => {
-    return [provider, providerConfigPublic(entries[provider])];
+    return [provider, providerConfigPublic(entries[provider] ?? getProviderConfigEntry(provider, host))];
   })));
 };
 

package/src/spawn-targets.ts

@@ -5,7 +5,7 @@ import { getRoutingPolicy } from "./routing-policy-store";
 import { isPathWithinBase } from "./utils";
 import { McpNotFoundError } from "./mcp-errors";
 import { DEFAULT_QUOTA_PREFER_SLACK_AT, DEFAULT_QUOTA_TARGET_UTILIZATION, quotaPaceMetrics } from "agent-relay-sdk/provider-quota";
-import type { ProviderQuotaRoutingConfig } from "agent-relay-sdk";
+import { isSpawnProvider, type ProviderQuotaRoutingConfig } from "agent-relay-sdk";
 import type { Orchestrator, ProviderCatalogSummary, ProviderQuotaBurnRole, ProviderQuotaBurnWindow, ProviderQuotaRecord, QuotaState, SpawnProvider } from "./types";
 
 // #308 — spawn discovery + target selection. Home for the live capability matrix that
@@ -159,7 +159,7 @@ export function providerQuotaAdvisories(now = Date.now()): Map<SpawnProvider, Sp
   const policy = getRoutingPolicy();
   const byProvider = new Map<SpawnProvider, ProviderQuotaRecord[]>();
   for (const record of listProviderQuotas({ historyLimit: 0, now }).quotas) {
-    if (record.provider !== "claude" && record.provider !== "codex") continue;
+    if (!isSpawnProvider(record.provider)) continue;
     const provider = record.provider;
     byProvider.set(provider, [...(byProvider.get(provider) ?? []), record]);
   }
@@ -231,8 +231,7 @@ function spawnQuotaWindow(
   // recency-weighted rate projects no early wall) replaces the blunt utilization floor, which
   // used to hide a legitimate low-util-high-burst alarm. Operators may still opt back in.
   const utilizationFloor = providerCfg?.burnPenaltyUtilizationFloor ?? 0;
-  const rawPenalty = (earlyFraction ?? 0) * weight;
-  const penalty = quotaWindow.utilization < utilizationFloor ? 0 : rawPenalty;
+  const pacePenalty = (earlyFraction ?? 0) * weight;
 
   // #760 — re-derive the pace projection against the PER-PROVIDER target (the stored burn used
   // the default). Slack is the symmetric underburn signal; prefer flags a window with no
@@ -249,6 +248,19 @@ function spawnQuotaWindow(
     projectedUtilAtReset = pace.projectedUtilAtReset;
     slack = pace.slack;
   }
+
+  // #798 — position penalty: an idle provider whose (de-biased) projection lands AT/OVER target is
+  // already over-extended, but its forward-wall pace penalty is 0 (no burn) — so without this the
+  // band would flip to "normal" and route big jobs onto a near-exhausted provider. Derive a STABLE
+  // penalty from the overshoot magnitude (slack < 0 ⇒ projectedUtilAtReset − target), decoupled
+  // from the jittery forward-burn term. Gated to idle (observedRatePerMs collapsed to 0): an ACTIVE
+  // provider is still governed entirely by the pace penalty (effective = max of the two), so this
+  // adds a floor for the parked-high case WITHOUT changing active routing. Under-target idle ⇒ 0.
+  const idle = burnWindow.observedRatePerMs !== null && burnWindow.observedRatePerMs <= 0;
+  const overshoot = slack !== null ? Math.max(0, -slack) : 0;
+  const positionPenalty = idle ? Math.min(1, overshoot / Math.max(1e-9, 1 - target)) * weight : 0;
+  const rawPenalty = Math.max(pacePenalty, positionPenalty);
+  const penalty = quotaWindow.utilization < utilizationFloor ? 0 : rawPenalty;
   const prefer = !blockedNow && penalty === 0
     && quotaPenaltyBandFor(penalty) === "normal"
     && slack !== null && slack >= preferSlackAt;
@@ -349,6 +361,22 @@ function quotaPenaltyBandFor(
   return "normal";
 }
 
+// #798 — classify a (penalty, slack) signal into a band. The single home for the
+// penalty-ladder + prefer-overlay mapping, shared by getProviderBandInfo's per-window band and the
+// band-transition notifier, which re-classifies the EMA-smoothed signal before thresholding. The
+// prefer overlay mirrors spawnQuotaWindow: a normal-band window projected ≥ preferSlackAt under
+// target reads "prefer".
+export function quotaBandFromSignal(
+  penalty: number,
+  slack: number | null,
+  quotaBands: Partial<{ cautionAt: number; avoidLargeAt: number; hardAvoidAt: number }> | undefined,
+  preferSlackAt: number,
+): QuotaBand {
+  const base = quotaPenaltyBandFor(penalty, quotaBands);
+  if (base === "normal" && slack !== null && slack >= preferSlackAt) return "prefer";
+  return base;
+}
+
 function recommendedAction(input: { quotaPenaltyBand: SpawnQuotaBurnBand; blockedNow: boolean; prefer: boolean; slack: number | null; windows: SpawnQuotaBurnWindow[] }): string {
   if (input.blockedNow) {
     const hasSevenDayBlock = input.windows.some((window) => window.role === "7d" && window.blockedNow);

package/src/sse.ts

@@ -1,4 +1,4 @@
-import { getAgent, getOrchestrator, matchingDeliveryAgents, onWorkspaceChange, sendMessageWithResult } from "./db";
+import { getAgent, getOrchestrator, matchingDeliveryAgents, onWorkspaceChange, sendMessageWithResult, setChannelSubscriberProbe } from "./db";
 import { projectAgentStatusData } from "./agent-card-projection";
 import { emitRelayEvent, subscribeRelayEvents, type RelayEvent } from "./events";
 import { messageMatchesAgent, targetMatchesAgent } from "./agent-ref";
@@ -20,6 +20,17 @@ const SSE_RETRY_MS = 5_000;
 
 subscribeRelayEvents((event) => fanout(event));
 
+// #797 — let the db layer derive outbound-channel liveness from live SSE subscriptions.
+// A channel agent is "subscribed" iff the channels-host daemon holds an open
+// GET /api/events?for=<channelAgentId> stream (createSSEStream stores `for` as agentId).
+export function hasActiveSubscriber(agentId: string): boolean {
+  for (const conn of connections.values()) {
+    if (conn.agentId === agentId) return true;
+  }
+  return false;
+}
+setChannelSubscriberProbe(hasActiveSubscriber);
+
 export function createSSEStream(agentId: string | null): Response {
   let connId: string;