feat(remote): give a proxied client the daemon's own failure envelope, cancellation, and version check

#2198 slice B. Direct-daemon and proxy execution over the same deterministic Simulator fixture
now publish the same responses, and the three places where they did not are closed:

- A client that disconnects mid-request behind the proxy now cancels the daemon request. The
  proxy's upstream fetch is bound to its client's connection, so the daemon's own disconnect
  cancellation (`markRequestCanceled`) fires exactly as it does for a direct client.
- The proxy forwards `GET /sessions/<session>/requests/<id>/diagnostics` (#1801), so a remote
  client behind it localizes a failure's diagnostics record instead of reporting
  `logPathUnavailable: HTTP 404`. GET only; the route still enumerates nothing.
- The client's ADR 0006 health check reads the `upstream` link a proxy's /health already nests:
  a proxy whose daemon speaks another RPC protocol fails at health, before the command RPC.

The provider scenario harness exposes its request boundary so a scenario daemon can sit behind a
real HTTP server and proxy; the new parity suite runs one script direct and proxied and compares
the published responses with transport identity removed, and proves two proxied clients
contending for one device fail at claim admission before any lifecycle call.

Author: thymikee

src/__tests__/daemon-proxy.test.ts

@@ -4,6 +4,7 @@ import crypto from 'node:crypto';
 import http from 'node:http';
 import { createDaemonProxyServer } from '../remote/daemon-proxy.ts';
 import { createDaemonHttpServer } from '../daemon/server/http-server.ts';
+import { getRequestSignal } from '@agent-device/host-kit/request';
 import { executeRunScriptHttpRequest } from '../daemon/adapters/maestro/run-script-http.ts';
 import {
   DAEMON_HTTP_NETWORK_ACCESS_HEADER,
@@ -173,6 +174,139 @@ test('proxy enforces public-only Maestro HTTP policy on a local daemon', async (
   }
 });
 
+test('daemon proxy cancels the upstream daemon request when its client disconnects', async (t) => {
+  if (await skipWhenLoopbackUnavailable(t)) return;
+
+  let upstreamStarted!: (requestId: string | undefined) => void;
+  const started = new Promise<string | undefined>((resolve) => {
+    upstreamStarted = resolve;
+  });
+  let upstreamCanceled!: (reason: string) => void;
+  const canceled = new Promise<string>((resolve) => {
+    upstreamCanceled = resolve;
+  });
+  const env = { ...process.env };
+  delete env.AGENT_DEVICE_HTTP_AUTH_HOOK;
+  delete env.AGENT_DEVICE_HTTP_AUTH_EXPORT;
+  const daemon = await createDaemonHttpServer({
+    token: 'daemon-secret',
+    env,
+    handleRequest: async (request) => {
+      const requestId = request.meta?.requestId;
+      const signal = getRequestSignal(requestId);
+      upstreamStarted(requestId);
+      if (!signal) {
+        upstreamCanceled('no request signal was registered');
+      } else if (signal.aborted) {
+        upstreamCanceled('aborted');
+      } else {
+        signal.addEventListener('abort', () => upstreamCanceled('aborted'), { once: true });
+      }
+      await canceled;
+      return { ok: false, error: { code: 'COMMAND_FAILED', message: 'request canceled' } };
+    },
+  });
+  const proxy = createDaemonProxyServer({
+    upstreamBaseUrl: `http://127.0.0.1:${await listenOnLoopback(daemon)}`,
+    upstreamToken: 'daemon-secret',
+    clientToken: 'proxy-secret',
+  });
+
+  try {
+    const proxyPort = await listenOnLoopback(proxy);
+    const client = http.request({
+      host: '127.0.0.1',
+      port: proxyPort,
+      method: 'POST',
+      path: '/agent-device/rpc',
+      headers: { 'content-type': 'application/json', authorization: 'Bearer proxy-secret' },
+    });
+    client.on('error', () => {});
+    client.end(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: 'req-disconnect',
+        method: 'agent_device.command',
+        params: {
+          token: 'proxy-secret',
+          session: 'default',
+          command: 'snapshot',
+          positionals: [],
+          flags: {},
+        },
+      }),
+    );
+    const requestId = await started;
+    assert.match(String(requestId), /req-disconnect/);
+
+    client.destroy();
+
+    const timeout = new Promise<string>((resolve) => {
+      setTimeout(() => resolve('upstream request was never canceled'), 5000).unref();
+    });
+    assert.equal(await Promise.race([canceled, timeout]), 'aborted');
+  } finally {
+    await closeLoopbackServer(proxy);
+    await closeLoopbackServer(daemon);
+  }
+});
+
+test('daemon proxy forwards a request diagnostics record fetch and nothing else on that path', async (t) => {
+  if (await skipWhenLoopbackUnavailable(t)) return;
+
+  const upstreamRequests: Array<{ method: string; url: string; auth: string }> = [];
+  const upstream = http.createServer((req, res) => {
+    upstreamRequests.push({
+      method: req.method ?? '',
+      url: req.url ?? '',
+      auth: String(req.headers.authorization ?? ''),
+    });
+    res.setHeader('content-type', 'application/x-ndjson');
+    res.end('{"phase":"request_failed"}\n');
+  });
+  const proxy = createDaemonProxyServer({
+    upstreamBaseUrl: `http://127.0.0.1:${await listenOnLoopback(upstream)}`,
+    upstreamToken: 'daemon-secret',
+    clientToken: 'proxy-secret',
+  });
+
+  try {
+    const proxyPort = await listenOnLoopback(proxy);
+    const record = `/agent-device/sessions/default/requests/req%3A1/diagnostics`;
+    const headers = { authorization: 'Bearer proxy-secret' };
+
+    const fetched = await fetch(`http://127.0.0.1:${proxyPort}${record}`, { headers });
+    assert.equal(fetched.status, 200);
+    assert.equal(await fetched.text(), '{"phase":"request_failed"}\n');
+    assert.deepEqual(upstreamRequests, [
+      {
+        method: 'GET',
+        url: '/sessions/default/requests/req%3A1/diagnostics',
+        auth: 'Bearer daemon-secret',
+      },
+    ]);
+
+    const unauthenticated = await fetch(`http://127.0.0.1:${proxyPort}${record}`);
+    assert.equal(unauthenticated.status, 401);
+    const posted = await fetch(`http://127.0.0.1:${proxyPort}${record}`, {
+      method: 'POST',
+      headers,
+    });
+    assert.equal(posted.status, 404);
+    const enumerated = await fetch(
+      `http://127.0.0.1:${proxyPort}/agent-device/sessions/default/requests`,
+      {
+        headers,
+      },
+    );
+    assert.equal(enumerated.status, 404);
+    assert.equal(upstreamRequests.length, 1, 'only the record fetch reaches the daemon');
+  } finally {
+    await closeLoopbackServer(proxy);
+    await closeLoopbackServer(upstream);
+  }
+});
+
 test('daemon proxy rejects unauthenticated rpc requests', async (t) => {
   if (await skipWhenLoopbackUnavailable(t)) return;
 

src/daemon/client/__tests__/daemon-client-health-compat.test.ts

@@ -0,0 +1,94 @@
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { test } from 'vitest';
+import { DAEMON_RPC_PROTOCOL_VERSION } from '@agent-device/contracts/daemon-http';
+import { readRemoteDaemonHealth } from '../daemon-client-transport.ts';
+import {
+  closeLoopbackServer,
+  listenOnLoopback,
+  skipWhenLoopbackUnavailable,
+} from '../../../__tests__/test-utils/loopback.ts';
+
+/**
+ * ADR 0006 health compatibility across every link a command RPC crosses. `sendToDaemon`
+ * runs this check before the RPC (daemon-client.test.ts pins that order); these cases pin
+ * what the check itself accepts and refuses when a proxy sits in front of the daemon.
+ */
+
+const DAEMON_LINK = { ok: true, service: 'agent-device-daemon', version: '98.0.0' } as const;
+
+async function withHealthServer<T>(
+  payload: Record<string, unknown>,
+  run: (baseUrl: string) => Promise<T>,
+): Promise<T> {
+  const server = http.createServer((req, res) => {
+    assert.equal(req.url, '/agent-device/health');
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(payload));
+  });
+  try {
+    const port = await listenOnLoopback(server);
+    return await run(`http://127.0.0.1:${port}/agent-device`);
+  } finally {
+    await closeLoopbackServer(server);
+  }
+}
+
+function proxyHealth(upstreamRpcProtocolVersion: number): Record<string, unknown> {
+  return {
+    ok: true,
+    service: 'agent-device-proxy',
+    version: '99.0.0',
+    rpcProtocolVersion: DAEMON_RPC_PROTOCOL_VERSION,
+    upstream: { ...DAEMON_LINK, rpcProtocolVersion: upstreamRpcProtocolVersion },
+  };
+}
+
+test('a proxy whose daemon speaks the same protocol passes with the upstream link readable', async (t) => {
+  if (await skipWhenLoopbackUnavailable(t)) return;
+
+  await withHealthServer(proxyHealth(DAEMON_RPC_PROTOCOL_VERSION), async (baseUrl) => {
+    const health = await readRemoteDaemonHealth({ baseUrl, token: 'proxy-token', pid: 0 });
+    assert.equal(health.reachable, true);
+    assert.equal(health.service, 'agent-device-proxy');
+    assert.deepEqual(health.upstream, {
+      service: 'agent-device-daemon',
+      version: '98.0.0',
+      rpcProtocolVersion: DAEMON_RPC_PROTOCOL_VERSION,
+    });
+  });
+});
+
+test('a proxy whose daemon speaks another protocol is refused, naming the daemon link', async (t) => {
+  if (await skipWhenLoopbackUnavailable(t)) return;
+
+  await withHealthServer(proxyHealth(DAEMON_RPC_PROTOCOL_VERSION + 1), async (baseUrl) => {
+    await assert.rejects(
+      readRemoteDaemonHealth({ baseUrl, token: 'proxy-token', pid: 0 }),
+      (error: unknown) => {
+        const details = (error as { code?: string; details?: Record<string, unknown> }).details;
+        assert.equal((error as { code?: string }).code, 'COMMAND_FAILED');
+        assert.match(String((error as Error).message), /RPC protocol is incompatible/);
+        assert.equal(details?.remoteService, 'agent-device-daemon');
+        assert.equal(details?.remoteVersion, '98.0.0');
+        assert.equal(details?.remoteRpcProtocolVersion, DAEMON_RPC_PROTOCOL_VERSION + 1);
+        assert.equal(details?.supportedRpcProtocolVersion, DAEMON_RPC_PROTOCOL_VERSION);
+        return true;
+      },
+    );
+  });
+});
+
+test('a daemon health payload without an upstream link parses as before', async (t) => {
+  if (await skipWhenLoopbackUnavailable(t)) return;
+
+  await withHealthServer(
+    { ...DAEMON_LINK, rpcProtocolVersion: DAEMON_RPC_PROTOCOL_VERSION },
+    async (baseUrl) => {
+      const health = await readRemoteDaemonHealth({ baseUrl, token: 'daemon-token', pid: 0 });
+      assert.equal(health.reachable, true);
+      assert.equal(health.upstream, undefined);
+      assert.equal(health.rpcProtocolVersion, DAEMON_RPC_PROTOCOL_VERSION);
+    },
+  );
+});

src/daemon/client/daemon-client-transport.ts

@@ -36,8 +36,15 @@ export type RemoteDaemonHealth = {
   service?: string;
   version?: string;
   rpcProtocolVersion?: number;
+  /** The daemon behind a proxy, as the proxy's health reported it. */
+  upstream?: RemoteDaemonHealthLink;
 };
 
+type RemoteDaemonHealthLink = Pick<
+  RemoteDaemonHealth,
+  'service' | 'version' | 'rpcProtocolVersion'
+>;
+
 export async function canConnect(
   info: DaemonInfo,
   preference: DaemonTransportPreference,
@@ -86,17 +93,21 @@ function canConnectHttp(info: DaemonInfo): Promise<boolean> {
 export async function readRemoteDaemonHealth(info: DaemonInfo): Promise<RemoteDaemonHealth> {
   const health = await readDaemonHttpHealth(info);
   if (!info.baseUrl || !health.reachable) return health;
-  if (
-    typeof health.rpcProtocolVersion === 'number' &&
-    health.rpcProtocolVersion !== DAEMON_RPC_PROTOCOL_VERSION
-  ) {
+  // Every link a command RPC crosses has to speak the client's protocol: a proxy that reports a
+  // skewed daemon behind it fails here, before the RPC, exactly like a skewed proxy does.
+  const incompatible = [health, health.upstream].find(
+    (link) =>
+      typeof link?.rpcProtocolVersion === 'number' &&
+      link.rpcProtocolVersion !== DAEMON_RPC_PROTOCOL_VERSION,
+  );
+  if (incompatible) {
     throw new AppError('COMMAND_FAILED', 'Remote daemon RPC protocol is incompatible', {
       daemonBaseUrl: info.baseUrl,
       clientVersion: readVersion(),
-      remoteVersion: health.version,
-      remoteService: health.service,
+      remoteVersion: incompatible.version,
+      remoteService: incompatible.service,
       supportedRpcProtocolVersion: DAEMON_RPC_PROTOCOL_VERSION,
-      remoteRpcProtocolVersion: health.rpcProtocolVersion,
+      remoteRpcProtocolVersion: incompatible.rpcProtocolVersion,
       hint: 'Upgrade agent-device on the client or remote host so both support the same daemon RPC protocol.',
     });
   }
@@ -156,22 +167,29 @@ async function readDaemonHttpHealth(info: DaemonInfo): Promise<RemoteDaemonHealt
 
 function readHealthPayload(body: string): Omit<RemoteDaemonHealth, 'reachable' | 'statusCode'> {
   try {
-    const parsed = JSON.parse(body) as {
-      service?: unknown;
-      version?: unknown;
-      rpcProtocolVersion?: unknown;
-    };
+    const parsed = JSON.parse(body) as { upstream?: unknown };
+    const upstream =
+      parsed.upstream && typeof parsed.upstream === 'object'
+        ? readHealthLink(parsed.upstream as Record<string, unknown>)
+        : undefined;
     return {
-      service: typeof parsed.service === 'string' ? parsed.service : undefined,
-      version: typeof parsed.version === 'string' ? parsed.version : undefined,
-      rpcProtocolVersion:
-        typeof parsed.rpcProtocolVersion === 'number' ? parsed.rpcProtocolVersion : undefined,
+      ...readHealthLink(parsed as Record<string, unknown>),
+      ...(upstream ? { upstream } : {}),
     };
   } catch {
     return {};
   }
 }
 
+function readHealthLink(parsed: Record<string, unknown>): RemoteDaemonHealthLink {
+  return {
+    service: typeof parsed.service === 'string' ? parsed.service : undefined,
+    version: typeof parsed.version === 'string' ? parsed.version : undefined,
+    rpcProtocolVersion:
+      typeof parsed.rpcProtocolVersion === 'number' ? parsed.rpcProtocolVersion : undefined,
+  };
+}
+
 export async function sendRequest(
   info: DaemonInfo,
   req: DaemonRequest,