@desplega.ai/agent-swarm 1.131.0 → 1.133.1

package/src/http/agents.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { ensure } from "@desplega.ai/business-use";
 import { z } from "zod";
 import {
+  computeContentHash,
   createAgent,
   deleteSwarmConfigByKey,
   getAgentById,
@@ -13,6 +14,7 @@ import {
   resetEmptyPollCount,
   setAgentHarnessProvider,
   updateAgentActivity,
+  updateAgentCredentialMissing,
   updateAgentCredentialState,
   updateAgentCredStatus,
   updateAgentMaxTasks,
@@ -22,10 +24,21 @@ import {
   updateAgentStatus,
   upsertSwarmConfig,
 } from "../be/db";
+import { createEvent } from "../be/events";
+import {
+  getRuntimeInstanceById,
+  listRuntimeInstancesForAgent,
+  reconcileAgentMaxTasksPolicy,
+  reconcileAgentStatusFromRuntimes,
+  runtimeStaleThresholdMinutes,
+  setRuntimeCredentialReady,
+  upsertRuntimeInstance,
+} from "../be/multi-runtime";
 import { reasoningCapability } from "../providers/reasoning-effort";
 import { ALL_CAPABILITIES, getEnabledCapabilities } from "../server";
 import { telemetry } from "../telemetry";
 import {
+  type Agent,
   AgentAvatarSchema,
   AgentCredStatusSchema,
   AgentLatestModelSchema,
@@ -35,11 +48,24 @@ import {
   type ProviderName,
   ProviderNameSchema,
   ReasoningEffortSchema,
+  RuntimeInstanceSchema,
 } from "../types";
 import { MAX_PROFILE_FILE_LENGTH } from "../utils/constants";
-import { route } from "./route-def";
+import {
+  type BudgetedIdentityField,
+  IDENTITY_FIELD_BUDGETS,
+  IdentityFieldBudgetError,
+} from "../utils/identity-field-budget";
+import { isMultiRuntimeEnabled } from "../utils/multi-runtime";
+import { scrubSecrets } from "../utils/secret-scrubber";
+import { route, runtimeInstanceHeader } from "./route-def";
 import { agentWithCapacity, json, jsonError } from "./utils";
 
+function singleHeaderValue(req: IncomingMessage, name: string): string | undefined {
+  const raw = req.headers[name];
+  return Array.isArray(raw) ? raw[0] : raw;
+}
+
 // ─── Route Definitions ───────────────────────────────────────────────────────
 
 /** Mirrors `CAPABILITIES_T` (src/server.ts) — the server's registered MCP tool-group flags. */
@@ -103,6 +129,13 @@ const registerAgent = route({
      * the canonical list — unknown values reject the request with 400.
      */
     harness_provider: ProviderNameSchema.optional(),
+    /**
+     * Per-process runtime identity; `X-Agent-ID` remains the logical agent.
+     * Ignored when MULTI_RUNTIME_ENABLED is off, required when it is on —
+     * schema-optional so older workers still parse, with the handler
+     * enforcing the mode-dependent requirement.
+     */
+    runtimeInstanceId: z.string().min(1).optional(),
   }),
   responses: {
     200: {
@@ -216,6 +249,41 @@ const getAgentSetupScript = route({
   },
 });
 
+/** Operator view of a runtime instance: internal `metadata` omitted, server-derived `isLive` added. */
+const AgentRuntimeInstanceSchema = RuntimeInstanceSchema.omit({ metadata: true }).extend({
+  isLive: z.boolean(),
+});
+
+const listAgentRuntimeInstances = route({
+  method: "get",
+  path: "/api/agents/{id}/runtime-instances",
+  pattern: ["api", "agents", null, "runtime-instances"],
+  summary: "List runtime instances serving an agent",
+  description:
+    "Read-only view of the worker processes currently registered for a logical agent. Rows exist only for multi-runtime registrations (MULTI_RUNTIME_ENABLED), so the list is empty in the default configuration. `isLive` combines `status` with `lastSeenAt` freshness against the server's staleness cutoff (`staleThresholdMinutes`); `reportedSlots` is each process's self-reported capacity, distinct from the agent's logical `maxTasks` policy.",
+  tags: ["Agents"],
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: {
+      description: "Runtime instances for the agent (empty when none are registered)",
+      schema: z.object({
+        runtimeInstances: z.array(AgentRuntimeInstanceSchema),
+        staleThresholdMinutes: z.number().int(),
+      }),
+    },
+    404: { description: "Agent not found" },
+  },
+});
+
+const ProfileSyncRejectionSchema = z.object({
+  field: z.enum(["soulMd", "identityMd", "claudeMd", "toolsMd"]),
+  diskSize: z.number().int(),
+  dbSize: z.number().int(),
+  budget: z.number().int(),
+  delta: z.number().int(),
+  reason: z.string(),
+});
+
 const updateAgentProfileRoute = route({
   method: "put",
   path: "/api/agents/{id}/profile",
@@ -227,11 +295,11 @@ const updateAgentProfileRoute = route({
     role: z.string().max(100).optional(),
     description: z.string().optional(),
     capabilities: z.array(z.string()).optional(),
-    claudeMd: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    soulMd: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    identityMd: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    claudeMd: z.string().optional(),
+    soulMd: z.string().optional(),
+    identityMd: z.string().optional(),
     setupScript: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
-    toolsMd: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
+    toolsMd: z.string().optional(),
     heartbeatMd: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
     /** `null` resets to the deterministic fallback; omit the key to leave untouched. */
     avatar: AgentAvatarSchema.nullable().optional(),
@@ -241,7 +309,13 @@ const updateAgentProfileRoute = route({
   }),
   responses: {
     200: { description: "Profile updated", schema: AgentWithCapacitySchema },
-    400: { description: "Validation error" },
+    400: {
+      description: "Validation or identity-field budget error",
+      schema: z.object({
+        error: z.string(),
+        profileSyncRejection: ProfileSyncRejectionSchema.optional(),
+      }),
+    },
     404: { description: "Agent not found" },
   },
 });
@@ -301,12 +375,14 @@ const updateAgentCredentialStatusRoute = route({
   summary: "Worker self-report of credential readiness (Phase 3 boot loop)",
   tags: ["Agents"],
   params: z.object({ id: z.string() }),
+  headers: runtimeInstanceHeader("report credential readiness"),
   body: credentialStatusBody,
   responses: {
     200: {
       description: "State updated; returns the agent row.",
       schema: AgentWithCapacitySchema,
     },
+    400: { description: "Missing X-Runtime-Instance-ID in multi-runtime mode" },
     404: { description: "Agent not found" },
   },
 });
@@ -354,6 +430,25 @@ export async function handleAgentRegister(
     if (!parsed) return true;
 
     const agentId = myAgentId || crypto.randomUUID();
+    // Read once so one mode applies consistently even if a config reload
+    // flips the flag mid-request.
+    const multiRuntime = isMultiRuntimeEnabled();
+
+    if (multiRuntime && parsed.body.runtimeInstanceId) {
+      // Runtime ownership is permanent: a runtime id already serving another
+      // agent must not be moved. `upsertRuntimeInstance` enforces this in SQL
+      // too; rejecting here keeps the failure legible and pre-mutation.
+      const existingRuntime = getRuntimeInstanceById(parsed.body.runtimeInstanceId);
+      if (existingRuntime && existingRuntime.agentId !== agentId) {
+        jsonError(res, "runtimeInstanceId is already registered to another agent", 400);
+        return true;
+      }
+    } else if (multiRuntime) {
+      // Enforced here rather than in the schema so the field stays optional
+      // for workers running against a server with the flag off.
+      jsonError(res, "runtimeInstanceId is required when multi-runtime mode is enabled", 400);
+      return true;
+    }
 
     const result = getDb().transaction(() => {
       const existingAgent = getAgentById(agentId);
@@ -361,7 +456,15 @@ export async function handleAgentRegister(
         if (existingAgent.status === "offline") {
           updateAgentStatus(existingAgent.id, "idle");
         }
-        if (parsed.body.maxTasks !== undefined && parsed.body.maxTasks !== existingAgent.maxTasks) {
+        if (multiRuntime) {
+          // body.maxTasks is this runtime's own capacity, recorded below; it
+          // must not redefine the logical policy, or two runtimes serving one
+          // agent would race to overwrite it.
+          reconcileAgentMaxTasksPolicy(existingAgent.id);
+        } else if (
+          parsed.body.maxTasks !== undefined &&
+          parsed.body.maxTasks !== existingAgent.maxTasks
+        ) {
           updateAgentMaxTasks(existingAgent.id, parsed.body.maxTasks);
         }
         if (parsed.body.provider && parsed.body.provider !== existingAgent.provider) {
@@ -379,6 +482,16 @@ export async function handleAgentRegister(
           setAgentHarnessProvider(existingAgent.id, parsed.body.harness_provider);
         }
         resetEmptyPollCount(existingAgent.id);
+        if (multiRuntime && parsed.body.runtimeInstanceId) {
+          upsertRuntimeInstance({
+            id: parsed.body.runtimeInstanceId,
+            agentId: existingAgent.id,
+            reportedSlots: parsed.body.maxTasks ?? 1,
+          });
+          // A new live runtime can lift the agent out of waiting without
+          // forcing idle over work another runtime is already doing.
+          reconcileAgentStatusFromRuntimes(existingAgent.id);
+        }
         return { agent: getAgentById(agentId), created: false };
       }
 
@@ -390,11 +503,29 @@ export async function handleAgentRegister(
         description: parsed.body.description,
         role: parsed.body.role,
         capabilities: parsed.body.capabilities ?? [],
+        // The first registration establishes the logical policy — including
+        // role defaults such as a lead's two concurrent tasks. Later
+        // registrations cannot change it; reconcile below only seeds.
         maxTasks: parsed.body.maxTasks ?? 1,
         provider: parsed.body.provider,
         harnessProvider: parsed.body.harness_provider ?? null,
       });
 
+      if (multiRuntime) {
+        // Re-fetch below: this may adopt a policy row an operator wrote
+        // before the agent existed.
+        reconcileAgentMaxTasksPolicy(agent.id);
+        if (parsed.body.runtimeInstanceId) {
+          upsertRuntimeInstance({
+            id: parsed.body.runtimeInstanceId,
+            agentId: agent.id,
+            reportedSlots: parsed.body.maxTasks ?? 1,
+          });
+          reconcileAgentStatusFromRuntimes(agent.id);
+        }
+        return { agent: getAgentById(agent.id), created: true };
+      }
+
       return { agent, created: true };
     })();
 
@@ -506,6 +637,22 @@ export async function handleAgentsRest(
     return true;
   }
 
+  if (listAgentRuntimeInstances.match(req.method, pathSegments)) {
+    const parsed = await listAgentRuntimeInstances.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!getAgentById(parsed.params.id)) {
+      jsonError(res, "Agent not found", 404);
+      return true;
+    }
+    listAgentRuntimeInstances.respond(res, 200, {
+      runtimeInstances: listRuntimeInstancesForAgent(parsed.params.id).map(
+        ({ metadata: _metadata, ...instance }) => instance,
+      ),
+      staleThresholdMinutes: runtimeStaleThresholdMinutes(),
+    });
+    return true;
+  }
+
   if (updateAgentProfileRoute.match(req.method, pathSegments)) {
     const parsed = await updateAgentProfileRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
@@ -545,30 +692,92 @@ export async function handleAgentsRest(
           }
         : undefined;
 
-    const agent = updateAgentProfile(
-      parsed.params.id,
-      {
-        role: body.role,
-        description: body.description,
-        capabilities: body.capabilities,
-        claudeMd: body.claudeMd,
-        soulMd: body.soulMd,
-        identityMd: body.identityMd,
-        setupScript: body.setupScript,
-        toolsMd: body.toolsMd,
-        heartbeatMd: body.heartbeatMd,
-        // Only include the key when the client sent it, so `null` (reset)
-        // is distinguishable from "not provided" (leave untouched).
-        ...(body.avatar !== undefined ? { avatar: body.avatar } : {}),
-      },
-      versionMeta,
-    );
+    let agent: Agent | null;
+    try {
+      agent = updateAgentProfile(
+        parsed.params.id,
+        {
+          role: body.role,
+          description: body.description,
+          capabilities: body.capabilities,
+          claudeMd: body.claudeMd,
+          soulMd: body.soulMd,
+          identityMd: body.identityMd,
+          setupScript: body.setupScript,
+          toolsMd: body.toolsMd,
+          heartbeatMd: body.heartbeatMd,
+          // Only include the key when the client sent it, so `null` (reset)
+          // is distinguishable from "not provided" (leave untouched).
+          ...(body.avatar !== undefined ? { avatar: body.avatar } : {}),
+        },
+        versionMeta,
+      );
+    } catch (error) {
+      if (error instanceof IdentityFieldBudgetError) {
+        if (
+          versionMeta?.changeSource === "self_edit" ||
+          versionMeta?.changeSource === "session_sync"
+        ) {
+          try {
+            createEvent({
+              category: "system",
+              event: "system.profile_sync_rejected",
+              status: "error",
+              source: "api",
+              agentId: parsed.params.id,
+              data: {
+                ...error.rejection,
+                dbHash: error.dbHash,
+                diskHash: error.diskHash,
+                changeSource: versionMeta.changeSource,
+              },
+            });
+          } catch (eventError) {
+            const message = eventError instanceof Error ? eventError.message : String(eventError);
+            console.error(
+              scrubSecrets(`[profile-sync] Failed to persist budget rejection event: ${message}`),
+            );
+          }
+        }
+        updateAgentProfileRoute.respond(res, 400, {
+          error: error.message,
+          profileSyncRejection: error.rejection,
+        });
+        return true;
+      }
+      throw error;
+    }
 
     if (!agent) {
       jsonError(res, "Agent not found", 404);
       return true;
     }
 
+    if (versionMeta?.changeSource === "self_edit" || versionMeta?.changeSource === "session_sync") {
+      try {
+        for (const field of Object.keys(IDENTITY_FIELD_BUDGETS) as BudgetedIdentityField[]) {
+          if (body[field] === undefined) continue;
+          createEvent({
+            category: "system",
+            event: "system.profile_sync_reconciled",
+            status: "ok",
+            source: "api",
+            agentId: parsed.params.id,
+            data: {
+              field,
+              dbHash: computeContentHash(agent[field] ?? ""),
+              changeSource: versionMeta.changeSource,
+            },
+          });
+        }
+      } catch (eventError) {
+        const message = eventError instanceof Error ? eventError.message : String(eventError);
+        console.error(
+          scrubSecrets(`[profile-sync] Failed to persist reconciliation event: ${message}`),
+        );
+      }
+    }
+
     updateAgentProfileRoute.respond(res, 200, agentWithCapacity(agent));
     return true;
   }
@@ -730,14 +939,36 @@ export async function handleAgentsRest(
       jsonError(res, "Agent not found", 404);
       return true;
     }
-    const agent =
-      parsed.body.ready !== undefined
-        ? (updateAgentCredentialState(
+    // Credential readiness is process-local. With several runtimes serving one
+    // agent, writing it straight onto the shared row lets the last reporter win
+    // — so the report is stored on its own runtime and the logical state is
+    // recomputed from all live runtimes.
+    const runtimeInstanceId = singleHeaderValue(req, "x-runtime-instance-id");
+    const multiRuntime = isMultiRuntimeEnabled();
+    // Only the readiness write is process-scoped; model/status metadata on this
+    // same endpoint stays agent-level and needs no runtime identity.
+    if (multiRuntime && parsed.body.ready !== undefined && !runtimeInstanceId) {
+      jsonError(res, "X-Runtime-Instance-ID is required when multi-runtime mode is enabled", 400);
+      return true;
+    }
+
+    let agent = existing;
+    if (parsed.body.ready !== undefined) {
+      if (multiRuntime && runtimeInstanceId) {
+        if (setRuntimeCredentialReady(runtimeInstanceId, parsed.params.id, parsed.body.ready)) {
+          updateAgentCredentialMissing(parsed.params.id, parsed.body.missing ?? null);
+          reconcileAgentStatusFromRuntimes(parsed.params.id);
+        }
+        agent = getAgentById(parsed.params.id) ?? existing;
+      } else {
+        agent =
+          updateAgentCredentialState(
             parsed.params.id,
             parsed.body.ready,
             parsed.body.missing ?? null,
-          ) ?? existing)
-        : existing;
+          ) ?? existing;
+      }
+    }
     if (!agent) {
       jsonError(res, "Agent not found", 404);
       return true;

package/src/http/all-routes.ts

@@ -17,6 +17,7 @@ import "./budgets";
 import "./codex-oauth-keep-warm";
 import "./config";
 import "./context";
+import "./core";
 import "./db-query";
 import "./ecosystem";
 

package/src/http/config.ts

@@ -8,8 +8,12 @@ import {
   getSwarmConfigLookupById,
   getSwarmConfigs,
   maskSecrets,
-  upsertSwarmConfig,
 } from "../be/db";
+import {
+  AGENT_MAX_TASKS_CONFIG_KEY,
+  resetAgentMaxTasksMirror,
+  upsertSwarmConfigWithPolicyMirror,
+} from "../be/multi-runtime";
 import { getUserGrant } from "../be/rbac-roles";
 import {
   isReservedConfigKey,
@@ -394,7 +398,7 @@ export async function handleConfig(
 
     try {
       const includeSecrets = queryParams.get("includeSecrets") === "true";
-      const config = upsertSwarmConfig({
+      const config = upsertSwarmConfigWithPolicyMirror({
         scope,
         scopeId: scopeId || null,
         key,
@@ -435,6 +439,13 @@ export async function handleConfig(
     if (existing.scope === "global") {
       scheduleIntegrationsReload();
     }
+    if (
+      existing.scope === "agent" &&
+      existing.scopeId &&
+      existing.key === AGENT_MAX_TASKS_CONFIG_KEY
+    ) {
+      resetAgentMaxTasksMirror(existing.scopeId);
+    }
     deleteConfig.respond(res, 200, { success: true });
     return true;
   }

package/src/http/core.ts

@@ -10,6 +10,11 @@ import {
   shouldBlockPolling,
   updateAgentStatus,
 } from "../be/db";
+import {
+  markRuntimeInstanceOffline,
+  reconcileAgentStatusFromRuntimes,
+  touchRuntimeInstance,
+} from "../be/multi-runtime";
 import { enqueueAdmissionRow } from "../be/rbac-audit";
 import { getUserGrant } from "../be/rbac-roles";
 import { initGitHub, resetGitHub } from "../github";
@@ -19,11 +24,12 @@ import { initLinear, resetLinear } from "../linear";
 import { decideAdmission, isRbacEnabled } from "../rbac";
 import { startSlackApp, stopSlackApp } from "../slack";
 import type { AgentStatus } from "../types";
+import { isMultiRuntimeEnabled } from "../utils/multi-runtime";
 import { setRequestAuth } from "../utils/request-auth-context";
 import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
 import { resolveHttpRequestAuth } from "./auth";
 import { generateOpenApiSpec, SCALAR_HTML } from "./openapi";
-import { findRoute, isPublicRoute } from "./route-def";
+import { findRoute, isPublicRoute, route, runtimeInstanceHeader } from "./route-def";
 import { agentWithCapacity, getPathSegments, jsonError, parseQueryParams } from "./utils";
 
 /**
@@ -273,6 +279,58 @@ export function _resetAutoReloadForTests(): void {
   autoReloadInvocations = 0;
 }
 
+function singleHeader(req: IncomingMessage, name: string): string | undefined {
+  const raw = req.headers[name];
+  return Array.isArray(raw) ? raw[0] : raw;
+}
+
+const RUNTIME_HEADER_DOC =
+  "Workers may send `X-Runtime-Instance-ID`, the per-boot identifier of the calling process. " +
+  "It is ignored unless MULTI_RUNTIME_ENABLED is set.";
+
+const pingRoute = route({
+  method: "post",
+  path: "/ping",
+  pattern: ["ping"],
+  summary: "Report agent liveness",
+  description:
+    `Refreshes the calling agent's status. ${RUNTIME_HEADER_DOC} With multi-runtime mode on, ` +
+    "the header must identify a live runtime of this agent; an absent, unknown, offline, or " +
+    "foreign identifier makes the call a no-op instead of an error, so workers predating the " +
+    "flag keep running.",
+  tags: ["Core"],
+  auth: { apiKey: true, agentId: true },
+  headers: runtimeInstanceHeader("refresh a runtime's liveness"),
+  rbac: { ungated: "self-scoped: an agent reports its own liveness" },
+  responses: {
+    204: { description: "Liveness recorded (or accepted as a no-op)" },
+    400: { description: "Missing X-Agent-ID header" },
+    404: { description: "Agent not found" },
+  },
+});
+
+const closeRoute = route({
+  method: "post",
+  path: "/close",
+  pattern: ["close"],
+  summary: "Mark an agent or runtime offline on shutdown",
+  description:
+    `Retires the calling process. ${RUNTIME_HEADER_DOC} With multi-runtime mode on, the header ` +
+    "is required and only that runtime is retired; the agent goes offline once no live runtime " +
+    "remains. With the flag off, the agent is marked offline as before.",
+  tags: ["Core"],
+  auth: { apiKey: true, agentId: true },
+  headers: runtimeInstanceHeader("retire a runtime"),
+  rbac: { ungated: "self-scoped: an agent retires its own runtime" },
+  responses: {
+    204: { description: "Runtime (and agent, when last) marked offline" },
+    400: {
+      description: "Missing X-Agent-ID, or missing X-Runtime-Instance-ID in multi-runtime mode",
+    },
+    404: { description: "Agent not found" },
+  },
+});
+
 export async function handleCore(
   req: IncomingMessage,
   res: ServerResponse,
@@ -473,13 +531,16 @@ export async function handleCore(
     return true;
   }
 
-  if (req.method === "POST" && req.url === "/ping") {
+  if (pingRoute.match(req.method, getPathSegments(req.url || ""))) {
     if (!myAgentId) {
       res.writeHead(400, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Missing X-Agent-ID header" }));
       return true;
     }
 
+    const runtimeInstanceId = singleHeader(req, "x-runtime-instance-id");
+    const multiRuntime = isMultiRuntimeEnabled();
+
     const tx = getDb().transaction(() => {
       const agent = getAgentById(myAgentId);
 
@@ -489,6 +550,18 @@ export async function handleCore(
         return false;
       }
 
+      if (multiRuntime) {
+        // Prove the identity before touching the agent: the status ladder
+        // below resolves `offline` to `idle`, so an anonymous, unknown, or
+        // already-closed runtime could otherwise revive an agent whose
+        // runtimes have all exited. Failing that check is a no-op rather
+        // than an error — ping is non-destructive, and rejecting it would
+        // break workers that predate the flag.
+        if (!runtimeInstanceId || !touchRuntimeInstance(runtimeInstanceId, agent.id)) {
+          return true;
+        }
+      }
+
       let status: AgentStatus = "idle";
 
       if (agent.status === "busy") {
@@ -514,13 +587,29 @@ export async function handleCore(
     return true;
   }
 
-  if (req.method === "POST" && req.url === "/close") {
+  if (closeRoute.match(req.method, getPathSegments(req.url || ""))) {
     if (!myAgentId) {
       res.writeHead(400, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Missing X-Agent-ID header" }));
       return true;
     }
 
+    const runtimeInstanceId = singleHeader(req, "x-runtime-instance-id");
+    const multiRuntime = isMultiRuntimeEnabled();
+
+    // Unlike ping, close is destructive, so it fails closed: an anonymous
+    // close would fall through to the legacy agent-wide close and take down
+    // an agent a sibling runtime is still serving.
+    if (multiRuntime && !runtimeInstanceId) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "X-Runtime-Instance-ID is required when multi-runtime mode is enabled",
+        }),
+      );
+      return true;
+    }
+
     const tx = getDb().transaction(() => {
       const agent = getAgentById(myAgentId);
 
@@ -530,7 +619,16 @@ export async function handleCore(
         return false;
       }
 
-      updateAgentStatus(agent.id, "offline");
+      if (multiRuntime && runtimeInstanceId) {
+        // One process exiting retires only its own runtime; the logical state
+        // is then recomputed from whatever is left — offline when nothing is,
+        // otherwise reflecting the surviving runtimes' readiness and work.
+        markRuntimeInstanceOffline(runtimeInstanceId, agent.id);
+        reconcileAgentStatusFromRuntimes(agent.id);
+      } else {
+        // Legacy semantics, with or without a runtime header.
+        updateAgentStatus(agent.id, "offline");
+      }
 
       return true;
     });