@mcoda/mswarm 0.1.79 → 0.1.81

package/dist/runtime.js

@@ -26,7 +26,12 @@ const DEFAULT_MCODA_LIST_ARGS = ["agent", "list", "--json", "--refresh-health"];
 const DEFAULT_COMMAND_MAX_BUFFER = 16 * 1024 * 1024;
 const DEFAULT_LOCAL_ARTIFACT_MAX_BYTES = 512 * 1024 * 1024;
 const DEFAULT_JOB_POLL_WAIT_MS = 25000;
+const DEFAULT_SELF_HOSTED_JOBS_POLL_PATH = "/v1/swarm/self-hosted/node/jobs/poll";
+const DEFAULT_SELF_HOSTED_JOBS_START_PATH_TEMPLATE = "/v1/swarm/self-hosted/node/jobs/:jobId/start";
+const DEFAULT_SELF_HOSTED_JOBS_EVENTS_PATH_TEMPLATE = "/v1/swarm/self-hosted/node/jobs/:jobId/events";
+const DEFAULT_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE = "/v1/swarm/self-hosted/node/jobs/:jobId/result";
 const DEFAULT_STREAM_EVENT_BATCH_SIZE = 8;
+const SELF_HOSTED_PROTOCOL_MISMATCH_CODE = "self_hosted_protocol_mismatch";
 const OWNER_LOCAL_TEST_ECHO_JOB_TYPE = "tenant.test-echo";
 const TEST_ECHO_RUNNER_ID = "test.echo";
 const RENDER_BLENDER_JOB_TYPE = "render.blender";
@@ -402,6 +407,37 @@ function parseCliOptions(argv) {
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/g, "");
 }
+function lifecyclePath(value, fallback) {
+    return optionalText(value) || fallback;
+}
+function resolveLifecycleUrl(gatewayBaseUrl, pathOrUrl) {
+    try {
+        return new URL(pathOrUrl).toString();
+    }
+    catch {
+        return new URL(pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`, `${trimTrailingSlash(gatewayBaseUrl)}/`).toString();
+    }
+}
+function resolveLifecycleTemplate(template, jobId) {
+    const encoded = encodeURIComponent(jobId);
+    return template
+        .replace(/:jobId\b/g, encoded)
+        .replace(/:job_id\b/g, encoded)
+        .replace(/\{jobId\}/g, encoded)
+        .replace(/\{job_id\}/g, encoded);
+}
+function usageFromTokenCounts(promptTokens, completionTokens) {
+    const prompt = positiveInteger(promptTokens) ?? 0;
+    const completion = positiveInteger(completionTokens) ?? 0;
+    return { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion };
+}
+function openAiUsage(response) {
+    const usage = isRecord(response?.usage) ? response.usage : undefined;
+    const prompt = positiveInteger(usage?.prompt_tokens) ?? 0;
+    const completion = positiveInteger(usage?.completion_tokens) ?? 0;
+    const total = positiveInteger(usage?.total_tokens) ?? prompt + completion;
+    return { prompt_tokens: prompt, completion_tokens: completion, total_tokens: total };
+}
 function defaultStatePath() {
     return join(homedir(), ".mswarm", "self-hosted-node", "config.json");
 }
@@ -592,12 +628,19 @@ function normalizeHealthStatus(value) {
         return "blocked";
     return "unknown";
 }
-function isMswarmManagedCloudAgent(agent) {
+function isMswarmManagedAgent(agent) {
     const config = agent.config && typeof agent.config === "object" ? agent.config : {};
-    const mswarmCloud = config.mswarmCloud;
-    return Boolean(mswarmCloud &&
-        typeof mswarmCloud === "object" &&
-        mswarmCloud.managed === true);
+    const managedConfigs = [config.mswarmCloud, config.mswarmSelfHosted, config.mswarmWorker];
+    if (managedConfigs.some((managedConfig) => Boolean(managedConfig) &&
+        typeof managedConfig === "object" &&
+        managedConfig.managed === true)) {
+        return true;
+    }
+    const slug = optionalText(agent.slug)?.toLowerCase();
+    return Boolean(slug &&
+        (slug.startsWith("mswarm-cloud-") ||
+            slug.startsWith("mswarm-self-hosted-") ||
+            slug.startsWith("mswarm-worker-")));
 }
 function isModelExposed(modelName, family, config) {
     if (config.modelBlocklist.includes(modelName)) {
@@ -624,6 +667,18 @@ function isAgentExposed(agentSlug, defaultModel, bestUsage, config) {
     }
     return config.exposeAllModels;
 }
+class HttpStatusError extends Error {
+    constructor(url, status, responseText) {
+        super(`request_failed:${status}:${responseText.slice(0, 200)}`);
+        this.name = "HttpStatusError";
+        this.url = url;
+        this.status = status;
+        this.responseText = responseText;
+    }
+}
+function isHttpStatusError(error, status) {
+    return error instanceof HttpStatusError && (status === undefined || error.status === status);
+}
 async function fetchJson(fetchImpl, url, init, timeoutMs) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -631,7 +686,7 @@ async function fetchJson(fetchImpl, url, init, timeoutMs) {
         const response = await fetchImpl(url, { ...init, signal: controller.signal });
         if (!response.ok) {
             const text = await response.text().catch(() => "");
-            throw new Error(`request_failed:${response.status}:${text.slice(0, 200)}`);
+            throw new HttpStatusError(url, response.status, text);
         }
         return (await response.json());
     }
@@ -1161,6 +1216,18 @@ export async function readSelfHostedNodeConfig(env = process.env) {
     const maxConcurrentLlmJobs = parsePositiveInteger(env.MSWARM_SELF_HOSTED_MAX_CONCURRENT_LLM_JOBS, state.max_concurrent_llm_jobs || maxConcurrentJobs);
     return {
         gatewayBaseUrl: trimTrailingSlash(gatewayBaseUrl),
+        jobsPollPath: optionalText(env.MSWARM_SELF_HOSTED_JOBS_POLL_PATH) ||
+            state.jobs_poll_path ||
+            DEFAULT_SELF_HOSTED_JOBS_POLL_PATH,
+        jobsStartPathTemplate: optionalText(env.MSWARM_SELF_HOSTED_JOBS_START_PATH_TEMPLATE) ||
+            state.jobs_start_path_template ||
+            DEFAULT_SELF_HOSTED_JOBS_START_PATH_TEMPLATE,
+        jobsEventsPathTemplate: optionalText(env.MSWARM_SELF_HOSTED_JOBS_EVENTS_PATH_TEMPLATE) ||
+            state.jobs_events_path_template ||
+            DEFAULT_SELF_HOSTED_JOBS_EVENTS_PATH_TEMPLATE,
+        jobsResultPathTemplate: optionalText(env.MSWARM_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE) ||
+            state.jobs_result_path_template ||
+            DEFAULT_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE,
         nodeId,
         serverName: optionalText(env.MSWARM_SELF_HOSTED_SERVER_NAME) || state.server_name || null,
         relayMode: parseRelayMode(env.MSWARM_SELF_HOSTED_RELAY_MODE || state.relay_mode),
@@ -1303,7 +1370,7 @@ export function mapOllamaModelToSelfHostedModel(model, config) {
     };
 }
 export function mapMcodaAgentToSelfHostedModel(agent, config) {
-    if (isMswarmManagedCloudAgent(agent)) {
+    if (isMswarmManagedAgent(agent)) {
         return null;
     }
     const slug = optionalText(agent.slug);
@@ -1684,6 +1751,7 @@ const PRE_START_JOB_ERROR_CODES = new Set([
     "validation_failed",
     "docdex_context_missing",
     "docdex_api_key_missing",
+    SELF_HOSTED_PROTOCOL_MISMATCH_CODE,
 ]);
 class SelfHostedDocdexJobError extends Error {
     constructor(code, message) {
@@ -1699,6 +1767,18 @@ class SelfHostedPreStartJobError extends Error {
         this.code = code;
     }
 }
+class SelfHostedProtocolMismatchError extends Error {
+    constructor(input) {
+        super(`Gateway is missing lifecycle endpoint ${input.endpoint} at ${input.gatewayBaseUrl} ` +
+            `(runtime package version ${input.runtimePackageVersion}). ` +
+            "Run a direct local agent/model instead, for example qwen3.6-llama.cpp.");
+        this.code = SELF_HOSTED_PROTOCOL_MISMATCH_CODE;
+        this.name = SELF_HOSTED_PROTOCOL_MISMATCH_CODE;
+        this.endpoint = input.endpoint;
+        this.gatewayBaseUrl = input.gatewayBaseUrl;
+        this.runtimePackageVersion = input.runtimePackageVersion;
+    }
+}
 function normalizeDocdexCapabilityMap(value) {
     const record = objectRecord(value);
     if (!record)
@@ -3207,9 +3287,36 @@ export class McodaLocalAgentExecutor {
 export class MswarmSelfHostedNodeClient {
     constructor(input) {
         this.gatewayBaseUrl = trimTrailingSlash(input.gatewayBaseUrl);
+        this.jobsPollPath = lifecyclePath(input.jobsPollPath, DEFAULT_SELF_HOSTED_JOBS_POLL_PATH);
+        this.jobsStartPathTemplate = lifecyclePath(input.jobsStartPathTemplate, DEFAULT_SELF_HOSTED_JOBS_START_PATH_TEMPLATE);
+        this.jobsEventsPathTemplate = lifecyclePath(input.jobsEventsPathTemplate, DEFAULT_SELF_HOSTED_JOBS_EVENTS_PATH_TEMPLATE);
+        this.jobsResultPathTemplate = lifecyclePath(input.jobsResultPathTemplate, DEFAULT_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE);
         this.fetchImpl = input.fetchImpl || fetch;
         this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
     }
+    lifecycleEndpoint(kind) {
+        const path = kind === "poll"
+            ? this.jobsPollPath
+            : kind === "start"
+                ? this.jobsStartPathTemplate
+                : kind === "events"
+                    ? this.jobsEventsPathTemplate
+                    : this.jobsResultPathTemplate;
+        return `POST ${path}`;
+    }
+    lifecycleGatewayBaseUrl() {
+        return this.gatewayBaseUrl;
+    }
+    lifecycleUrl(kind, jobId) {
+        const path = kind === "poll"
+            ? this.jobsPollPath
+            : kind === "start"
+                ? this.jobsStartPathTemplate
+                : kind === "events"
+                    ? this.jobsEventsPathTemplate
+                    : this.jobsResultPathTemplate;
+        return resolveLifecycleUrl(this.gatewayBaseUrl, jobId ? resolveLifecycleTemplate(path, jobId) : path);
+    }
     async enroll(nodeId, enrollmentToken) {
         return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/enroll`, {
             method: "POST",
@@ -3261,7 +3368,7 @@ export class MswarmSelfHostedNodeClient {
         }, this.timeoutMs);
     }
     async pollJob(runtimeToken, payload) {
-        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/jobs/poll`, {
+        return fetchJson(this.fetchImpl, this.lifecycleUrl("poll"), {
             method: "POST",
             headers: {
                 "content-type": "application/json",
@@ -3271,7 +3378,7 @@ export class MswarmSelfHostedNodeClient {
         }, Math.max(this.timeoutMs, (payload.wait_ms || 0) + 5000));
     }
     async postJobResult(runtimeToken, jobId, payload) {
-        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/jobs/${encodeURIComponent(jobId)}/result`, {
+        return fetchJson(this.fetchImpl, this.lifecycleUrl("result", jobId), {
             method: "POST",
             headers: {
                 "content-type": "application/json",
@@ -3281,7 +3388,7 @@ export class MswarmSelfHostedNodeClient {
         }, this.timeoutMs);
     }
     async postJobStart(runtimeToken, jobId, payload) {
-        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/jobs/${encodeURIComponent(jobId)}/start`, {
+        return fetchJson(this.fetchImpl, this.lifecycleUrl("start", jobId), {
             method: "POST",
             headers: {
                 "content-type": "application/json",
@@ -3291,7 +3398,7 @@ export class MswarmSelfHostedNodeClient {
         }, this.timeoutMs);
     }
     async postJobEvents(runtimeToken, jobId, payload) {
-        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/jobs/${encodeURIComponent(jobId)}/events`, {
+        return fetchJson(this.fetchImpl, this.lifecycleUrl("events", jobId), {
             method: "POST",
             headers: {
                 "content-type": "application/json",
@@ -3309,11 +3416,16 @@ export class SelfHostedNodeRuntime {
         this.queuedGenericJobs = 0;
         this.latencySamplesMs = [];
         this.recentFailures = [];
+        this.lifecyclePollingDisabled = false;
         this.config = config;
         this.gateway =
             deps?.gateway ||
                 new MswarmSelfHostedNodeClient({
                     gatewayBaseUrl: config.gatewayBaseUrl,
+                    jobsPollPath: config.jobsPollPath,
+                    jobsStartPathTemplate: config.jobsStartPathTemplate,
+                    jobsEventsPathTemplate: config.jobsEventsPathTemplate,
+                    jobsResultPathTemplate: config.jobsResultPathTemplate,
                     fetchImpl: deps?.fetchImpl,
                     timeoutMs: config.requestTimeoutMs
                 });
@@ -3388,6 +3500,53 @@ export class SelfHostedNodeRuntime {
             this.recentFailures.splice(MAX_TELEMETRY_FAILURES);
         }
     }
+    lifecycleProtocolMismatch(kind, error) {
+        if (!isHttpStatusError(error, 404)) {
+            return undefined;
+        }
+        return new SelfHostedProtocolMismatchError({
+            endpoint: this.gateway.lifecycleEndpoint(kind),
+            gatewayBaseUrl: this.gateway.lifecycleGatewayBaseUrl(),
+            runtimePackageVersion: this.config.nodeVersion
+        });
+    }
+    isLifecycleProtocolDegradedState(state) {
+        return state?.lifecycle_health_reason === SELF_HOSTED_PROTOCOL_MISMATCH_CODE;
+    }
+    async readLifecycleState() {
+        try {
+            return await readSelfHostedNodeState(this.config.statePath);
+        }
+        catch {
+            return {};
+        }
+    }
+    async markLifecycleProtocolDegraded(error) {
+        this.lifecyclePollingDisabled = true;
+        this.recentFailures.unshift({
+            execution_class: "agentic",
+            code: SELF_HOSTED_PROTOCOL_MISMATCH_CODE,
+            at: new Date().toISOString()
+        });
+        this.recentFailures.splice(MAX_TELEMETRY_FAILURES);
+        const state = await this.readLifecycleState();
+        await writeSelfHostedNodeState(this.config.statePath, {
+            ...state,
+            lifecycle_health_status: "degraded",
+            lifecycle_health_reason: SELF_HOSTED_PROTOCOL_MISMATCH_CODE,
+            lifecycle_health_message: error.message,
+            lifecycle_health_updated_at: new Date().toISOString()
+        });
+    }
+    jobResultPayload(result) {
+        return {
+            ...result,
+            node_id: this.config.nodeId,
+            ...(result.status === "success"
+                ? { usage: result.usage || openAiUsage(result.openai_response) }
+                : {})
+        };
+    }
     averageLatencyMs(fallback = null) {
         if (this.latencySamplesMs.length === 0) {
             return fallback;
@@ -3481,6 +3640,12 @@ export class SelfHostedNodeRuntime {
             throw new Error("Bootstrap response did not include node_id and runtime_token");
         }
         const heartbeatInterval = bootstrap.heartbeat_interval_seconds || setupConfig.heartbeatIntervalSeconds;
+        const relay = bootstrap.relay || {};
+        const relayGatewayBaseUrl = optionalText(relay.gateway_base_url) || setupConfig.gatewayBaseUrl;
+        const jobsPollPath = lifecyclePath(relay.jobs_poll_path, DEFAULT_SELF_HOSTED_JOBS_POLL_PATH);
+        const jobsStartPathTemplate = lifecyclePath(relay.jobs_start_path_template, DEFAULT_SELF_HOSTED_JOBS_START_PATH_TEMPLATE);
+        const jobsEventsPathTemplate = lifecyclePath(relay.jobs_events_path_template, DEFAULT_SELF_HOSTED_JOBS_EVENTS_PATH_TEMPLATE);
+        const jobsResultPathTemplate = lifecyclePath(relay.jobs_result_path_template, DEFAULT_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE);
         const state = {
             node_id: nodeId,
             server_name: optionalText(bootstrap.node?.server_name) || setupConfig.serverName,
@@ -3494,7 +3659,15 @@ export class SelfHostedNodeRuntime {
             heartbeat_timeout_seconds: bootstrap.heartbeat_timeout_seconds,
             enrolled_at: new Date().toISOString(),
             updated_at: new Date().toISOString(),
-            gateway_base_url: setupConfig.gatewayBaseUrl,
+            gateway_base_url: trimTrailingSlash(relayGatewayBaseUrl),
+            jobs_poll_path: jobsPollPath,
+            jobs_start_path_template: jobsStartPathTemplate,
+            jobs_events_path_template: jobsEventsPathTemplate,
+            jobs_result_path_template: jobsResultPathTemplate,
+            lifecycle_health_status: "healthy",
+            lifecycle_health_reason: undefined,
+            lifecycle_health_message: undefined,
+            lifecycle_health_updated_at: new Date().toISOString(),
             ollama_base_url: setupConfig.ollamaBaseUrl,
             discovery_mode: setupConfig.discoveryMode,
             mcoda_bin: setupConfig.mcodaBin,
@@ -3518,8 +3691,23 @@ export class SelfHostedNodeRuntime {
         };
         await writeSelfHostedNodeState(setupConfig.statePath, state);
         await writeSelfHostedRuntimeToken(setupConfig.runtimeTokenPath, runtimeToken);
+        const runtimeGateway = deps?.gateway && trimTrailingSlash(relayGatewayBaseUrl) === setupConfig.gatewayBaseUrl
+            ? deps.gateway
+            : new MswarmSelfHostedNodeClient({
+                gatewayBaseUrl: trimTrailingSlash(relayGatewayBaseUrl),
+                jobsPollPath,
+                jobsStartPathTemplate,
+                jobsEventsPathTemplate,
+                jobsResultPathTemplate,
+                fetchImpl: deps?.fetchImpl,
+                timeoutMs: setupConfig.requestTimeoutMs
+            });
         const runtime = new SelfHostedNodeRuntime({
-            gatewayBaseUrl: setupConfig.gatewayBaseUrl,
+            gatewayBaseUrl: trimTrailingSlash(relayGatewayBaseUrl),
+            jobsPollPath,
+            jobsStartPathTemplate,
+            jobsEventsPathTemplate,
+            jobsResultPathTemplate,
             nodeId,
             serverName: state.server_name,
             relayMode: state.relay_mode || setupConfig.relayMode,
@@ -3553,7 +3741,7 @@ export class SelfHostedNodeRuntime {
             exposeAllModels: setupConfig.exposeAllModels,
             modelAllowlist: setupConfig.modelAllowlist,
             modelBlocklist: setupConfig.modelBlocklist
-        }, { ...deps, gateway });
+        }, { ...deps, gateway: runtimeGateway });
         const once = await runtime.runOnce();
         return {
             created: bootstrap.created === true,
@@ -3639,6 +3827,12 @@ export class SelfHostedNodeRuntime {
         if (!runtimeToken) {
             throw new Error("Enrollment response did not include runtime_token");
         }
+        const relay = response.relay || {};
+        const gatewayBaseUrl = trimTrailingSlash(optionalText(relay.gateway_base_url) || this.config.gatewayBaseUrl);
+        const jobsPollPath = lifecyclePath(relay.jobs_poll_path || this.config.jobsPollPath, DEFAULT_SELF_HOSTED_JOBS_POLL_PATH);
+        const jobsStartPathTemplate = lifecyclePath(relay.jobs_start_path_template || this.config.jobsStartPathTemplate, DEFAULT_SELF_HOSTED_JOBS_START_PATH_TEMPLATE);
+        const jobsEventsPathTemplate = lifecyclePath(relay.jobs_events_path_template || this.config.jobsEventsPathTemplate, DEFAULT_SELF_HOSTED_JOBS_EVENTS_PATH_TEMPLATE);
+        const jobsResultPathTemplate = lifecyclePath(relay.jobs_result_path_template || this.config.jobsResultPathTemplate, DEFAULT_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE);
         const nextState = {
             ...currentState,
             node_id: this.config.nodeId,
@@ -3648,7 +3842,15 @@ export class SelfHostedNodeRuntime {
             heartbeat_timeout_seconds: response.heartbeat_timeout_seconds,
             enrolled_at: currentState.enrolled_at || new Date().toISOString(),
             updated_at: new Date().toISOString(),
-            gateway_base_url: this.config.gatewayBaseUrl,
+            gateway_base_url: gatewayBaseUrl,
+            jobs_poll_path: jobsPollPath,
+            jobs_start_path_template: jobsStartPathTemplate,
+            jobs_events_path_template: jobsEventsPathTemplate,
+            jobs_result_path_template: jobsResultPathTemplate,
+            lifecycle_health_status: "healthy",
+            lifecycle_health_reason: undefined,
+            lifecycle_health_message: undefined,
+            lifecycle_health_updated_at: new Date().toISOString(),
             ollama_base_url: this.config.ollamaBaseUrl,
             discovery_mode: this.config.discoveryMode,
             mcoda_bin: this.config.mcodaBin,
@@ -3959,6 +4161,8 @@ export class SelfHostedNodeRuntime {
                         ]
                     });
                 }
+                const promptTokens = positiveInteger(ollamaResult.promptTokens);
+                const completionTokens = positiveInteger(ollamaResult.completionTokens);
                 const invocationResult = {
                     job_id: job.job_id,
                     request_id: job.request_id,
@@ -3967,10 +4171,11 @@ export class SelfHostedNodeRuntime {
                         requestId: job.request_id,
                         model: job.openai_request.model,
                         content: ollamaResult.content,
-                        promptTokens: ollamaResult.promptTokens,
-                        completionTokens: ollamaResult.completionTokens,
+                        promptTokens,
+                        completionTokens,
                         metadata: { provider: "ollama", raw: ollamaResult.raw }
                     }),
+                    usage: usageFromTokenCounts(promptTokens, completionTokens),
                     ...(streamEvents.length ? { stream_events: streamEvents } : {}),
                     ...(progressEvents.length ? { progress_events: progressEvents } : {}),
                     timing: { local_latency_ms: Date.now() - startedAt }
@@ -4051,6 +4256,7 @@ export class SelfHostedNodeRuntime {
                         mode: response.metadata.mode
                     }
                 }),
+                usage: usageFromTokenCounts(tokens.promptTokens, tokens.completionTokens),
                 ...(streamEvents.length ? { stream_events: streamEvents } : {}),
                 ...(progressEvents.length ? { progress_events: progressEvents } : {}),
                 timing: { local_latency_ms: Date.now() - startedAt }
@@ -4117,6 +4323,13 @@ export class SelfHostedNodeRuntime {
             models = [];
             version = null;
         }
+        const lifecycleState = await this.readLifecycleState();
+        const lifecycleProtocolDegraded = this.isLifecycleProtocolDegradedState(lifecycleState);
+        if (lifecycleProtocolDegraded) {
+            status = "degraded";
+            recentFailureCount = Math.max(recentFailureCount, 1);
+            this.lifecyclePollingDisabled = true;
+        }
         const discoveryLatencyMs = Date.now() - startedAt;
         const capabilityPayload = await this.buildCapabilityHeartbeatPayload(enrollment.runtimeToken);
         const loadTelemetry = this.buildLoadTelemetry({
@@ -4158,7 +4371,17 @@ export class SelfHostedNodeRuntime {
                 relay_mode: this.config.relayMode || "outbound",
                 load_reporting_enabled: loadReportingEnabled,
                 hardware_telemetry_enabled: this.config.hardwareTelemetryEnabled === true,
-                drain_mode: this.config.drainMode === true
+                drain_mode: this.config.drainMode === true,
+                ...(lifecycleProtocolDegraded
+                    ? {
+                        lifecycle: {
+                            status: "degraded",
+                            reason: lifecycleState.lifecycle_health_reason,
+                            message: lifecycleState.lifecycle_health_message,
+                            updated_at: lifecycleState.lifecycle_health_updated_at
+                        }
+                    }
+                    : {})
             },
             discovery: {
                 source: discoverySource,
@@ -4178,7 +4401,14 @@ export class SelfHostedNodeRuntime {
                 avg_latency_ms: loadTelemetry.avg_latency_ms ?? discoveryLatencyMs,
                 recent_failure_count: loadTelemetry.recent_failure_count,
                 recent_failures: loadTelemetry.recent_failures,
-                last_success_at: status === "online" ? new Date().toISOString() : null
+                last_success_at: status === "online" ? new Date().toISOString() : null,
+                ...(lifecycleProtocolDegraded
+                    ? {
+                        lifecycle_status: "degraded",
+                        lifecycle_reason: lifecycleState.lifecycle_health_reason,
+                        lifecycle_message: lifecycleState.lifecycle_health_message
+                    }
+                    : {})
             },
             local_agent_catalog: {
                 revision: loadTelemetry.catalog_fingerprint,
@@ -4232,20 +4462,36 @@ export class SelfHostedNodeRuntime {
         return { count: models.filter((model) => model.exposed !== false).length, response };
     }
     async pollAndExecuteJob(waitMs = DEFAULT_JOB_POLL_WAIT_MS) {
+        const lifecycleState = await this.readLifecycleState();
+        if (this.lifecyclePollingDisabled || this.isLifecycleProtocolDegradedState(lifecycleState)) {
+            this.lifecyclePollingDisabled = true;
+            return { executed: false, status: "failed" };
+        }
         const enrollment = await this.ensureEnrolled();
         const pollCapacity = this.buildLoadTelemetry({ models: [] });
-        const response = await this.gateway.pollJob(enrollment.runtimeToken, {
-            node_id: this.config.nodeId,
-            capacity: {
-                active_jobs: pollCapacity.active_jobs,
-                queued_jobs: pollCapacity.queued_jobs,
-                max_jobs: pollCapacity.max_concurrency,
-                max_concurrency: pollCapacity.max_concurrency,
-                free_slots: pollCapacity.free_slots,
-                drain_mode: pollCapacity.drain_mode
-            },
-            wait_ms: waitMs
-        });
+        let response;
+        try {
+            response = await this.gateway.pollJob(enrollment.runtimeToken, {
+                node_id: this.config.nodeId,
+                capacity: {
+                    active_jobs: pollCapacity.active_jobs,
+                    queued_jobs: pollCapacity.queued_jobs,
+                    max_jobs: pollCapacity.max_concurrency,
+                    max_concurrency: pollCapacity.max_concurrency,
+                    free_slots: pollCapacity.free_slots,
+                    drain_mode: pollCapacity.drain_mode
+                },
+                wait_ms: waitMs
+            });
+        }
+        catch (error) {
+            const mismatch = this.lifecycleProtocolMismatch("poll", error);
+            if (mismatch) {
+                await this.markLifecycleProtocolDegraded(mismatch);
+                return { executed: false, status: "failed" };
+            }
+            throw error;
+        }
         const job = response.job || null;
         if (!job) {
             return { executed: false };
@@ -4265,19 +4511,35 @@ export class SelfHostedNodeRuntime {
                 });
                 forwardedStreamEventCount += stream_events.length;
             }
-            catch {
+            catch (error) {
+                const mismatch = this.lifecycleProtocolMismatch("events", error);
+                if (mismatch) {
+                    streamEventForwardingFailed = true;
+                    await this.markLifecycleProtocolDegraded(mismatch);
+                    throw mismatch;
+                }
                 streamEventForwardingFailed = true;
             }
         };
-        const result = await this.executeJob(job, {
+        let result = await this.executeJob(job, {
             attachedMswarmApiKey: optionalText(response.attached_mswarm_api_key) || undefined,
             onStarted: async (event) => {
-                await this.gateway.postJobStart(enrollment.runtimeToken, job.job_id, {
-                    node_id: this.config.nodeId,
-                    agent_slug: event.agent_slug || job.agent_slug,
-                    source_agent_slug: event.source_agent_slug || job.source_agent_slug || null,
-                    model: event.model || job.model || job.openai_request.model
-                });
+                try {
+                    await this.gateway.postJobStart(enrollment.runtimeToken, job.job_id, {
+                        node_id: this.config.nodeId,
+                        agent_slug: event.agent_slug || job.agent_slug,
+                        source_agent_slug: event.source_agent_slug || job.source_agent_slug || null,
+                        model: event.model || job.model || job.openai_request.model
+                    });
+                }
+                catch (error) {
+                    const mismatch = this.lifecycleProtocolMismatch("start", error);
+                    if (mismatch) {
+                        await this.markLifecycleProtocolDegraded(mismatch);
+                        throw mismatch;
+                    }
+                    throw error;
+                }
             },
             onOpenAIChunk: async (chunk) => {
                 if (job.openai_request.stream !== true || streamEventForwardingFailed) {
@@ -4289,7 +4551,23 @@ export class SelfHostedNodeRuntime {
                 }
             },
         });
-        await flushStreamEvents();
+        try {
+            await flushStreamEvents();
+        }
+        catch (error) {
+            if (!(error instanceof SelfHostedProtocolMismatchError)) {
+                throw error;
+            }
+            result = {
+                job_id: job.job_id,
+                request_id: job.request_id,
+                status: "failed",
+                error: { code: SELF_HOSTED_PROTOCOL_MISMATCH_CODE, message: error.message },
+                ...(result.stream_events?.length ? { stream_events: result.stream_events } : {}),
+                ...(result.progress_events?.length ? { progress_events: result.progress_events } : {}),
+                timing: result.timing
+            };
+        }
         const postedResult = job.openai_request.stream === true
             ? streamEventForwardingFailed
                 ? {
@@ -4298,10 +4576,17 @@ export class SelfHostedNodeRuntime {
                 }
                 : (({ stream_events: _streamEvents, ...rest }) => rest)(result)
             : result;
-        await this.gateway.postJobResult(enrollment.runtimeToken, job.job_id, {
-            ...postedResult,
-            node_id: this.config.nodeId
-        });
+        try {
+            await this.gateway.postJobResult(enrollment.runtimeToken, job.job_id, this.jobResultPayload(postedResult));
+        }
+        catch (error) {
+            const mismatch = this.lifecycleProtocolMismatch("result", error);
+            if (mismatch) {
+                await this.markLifecycleProtocolDegraded(mismatch);
+                return { executed: true, job_id: job.job_id, status: "failed" };
+            }
+            throw error;
+        }
         return { executed: true, job_id: job.job_id, status: result.status };
     }
     async doctor() {
@@ -4343,7 +4628,7 @@ export class SelfHostedNodeRuntime {
         let timer = null;
         let polling = false;
         const poll = () => {
-            if (stopped || polling || this.config.relayMode === "direct")
+            if (stopped || polling || this.lifecyclePollingDisabled || this.config.relayMode === "direct")
                 return;
             polling = true;
             void this.pollAndExecuteJob()