test(runtime): move the consumer pins onto the converted refusal envelope (#9364)

packages/runtime drives the hono adapter through the dispatcher plugin, and
its integration tests pin the adapter's refusal bodies. Those pins still
asserted the pre-conversion shapes.

Adapter pins, moved — verified as adapter pins rather than another door's
contract by reading what each case exists to prove:

- dispatcher-plugin.multi-tenant-endpoint (2 sites) and
  dispatcher-plugin.ready — both assert "the transport's own 404 stands", one
  as the decline branch of environment resolution, one as an explicit
  anti-vacuity control that the harness mirrors prod.
- dispatcher-plugin.endpoint-fallback — BARE_NOT_FOUND renamed
  TRANSPORT_NOT_FOUND (the name described the old shape) across 6 uses, plus
  the 405 case whose code/allowed moved into error / error.details.
- mcp-skill-method-not-allowed — the boundary case now reads
  error.details.allowed, asserted by value (the four-verb set #7649's own fix
  produces) rather than by presence.

⚠️ The conversion also drained the POST/DELETE cases in that last file of
their discriminating power without failing: they separated the two doors by
`typeof body.error !== 'string'` and three top-level not.toHaveProperty
checks, all four of which became true of the ADAPTER answer too once it
gained the same envelope. Replaced with the distinction that still holds —
the domain fills error.httpStatus and no details, the adapter the reverse —
so the suite still fails in the world it exists to catch.

Assertions are at least as strong as before; none weakened or skipped, no
ratchet touched. check-route-envelope counters unchanged.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012WKSnqAaoqtW3QX7SSf1Vk

Author: claude

packages/runtime/src/dispatcher-plugin.endpoint-fallback.integration.test.ts

@@ -19,8 +19,8 @@
  *
  * The load-bearing assertion in most of these is a NEGATIVE one: that adding
  * this seam changed nothing for anybody who did not ask for it. The unmatched
- * answers — the bare 404 and the 405 + `Allow` — must come back byte for byte
- * for every path no declaration owns. Since the #5040 E7 publish flip that is
+ * answers — the transport's 404 and the 405 + `Allow` — must come back byte for
+ * byte for every path no declaration owns. Since the #5040 E7 publish flip that is
  * the assertion's whole weight: stacks CAN declare endpoints now, so "the
  * fallback stays silent unless a declaration matches" is a promise to live
  * deployments rather than a property of a surface nothing could reach.
@@ -123,8 +123,18 @@ async function shutdown(kernel: LiteKernel | undefined) {
     ]);
 }
 
-/** The transport's unmatched answer, captured from a boot with no seam armed. */
-const BARE_NOT_FOUND = { error: 'Not found' };
+/**
+ * The transport's unmatched answer, captured from a boot with no seam armed.
+ *
+ * The hono adapter's `unmatchedResponse()` — the declared refusal envelope
+ * since #9364, previously the bare `{ error: 'Not found' }`. Every use below
+ * is asserting "the transport answered, the seam did not", so the value has to
+ * track the adapter; what those cases pin is the ROUTING, not the wording.
+ */
+const TRANSPORT_NOT_FOUND = {
+    success: false,
+    error: { code: 'ENDPOINT_NOT_FOUND', message: 'Not found' },
+};
 
 describe('metadata slot carries no matchEndpoint — a fully working passthrough', () => {
     let kernel: LiteKernel;
@@ -139,7 +149,7 @@ describe('metadata slot carries no matchEndpoint — a fully working passthrough
     it('answers an endpoint-shaped path with the transport\'s own 404, unchanged', async () => {
         const res = await fetch(`${baseUrl}/api/v1/apps/showcase/tasks`);
         expect(res.status).toBe(404);
-        expect(await res.json()).toEqual(BARE_NOT_FOUND);
+        expect(await res.json()).toEqual(TRANSPORT_NOT_FOUND);
     });
 
     it('serves the dispatcher\'s own routes normally', async () => {
@@ -158,7 +168,7 @@ describe('no metadata service at all', () => {
     it('answers 404 rather than failing the request', async () => {
         const res = await fetch(`${baseUrl}/api/v1/apps/showcase/tasks`);
         expect(res.status).toBe(404);
-        expect(await res.json()).toEqual(BARE_NOT_FOUND);
+        expect(await res.json()).toEqual(TRANSPORT_NOT_FOUND);
     });
 });
 
@@ -198,15 +208,15 @@ describe('matcher present — the endpoint dispatch step (#5090)', () => {
     it('answers a MISS under the mount with the transport\'s 404, unchanged', async () => {
         const res = await fetch(`${baseUrl}/api/v1/apps/showcase/nope`);
         expect(res.status).toBe(404);
-        expect(await res.json()).toEqual(BARE_NOT_FOUND);
+        expect(await res.json()).toEqual(TRANSPORT_NOT_FOUND);
         expect(queries).toContainEqual({ path: '/api/v1/apps/showcase/nope', method: 'GET' });
     });
 
     it('never consults the matcher for a path outside the mount', async () => {
         queries.length = 0;
         const res = await fetch(`${baseUrl}/api/v1/nope`);
         expect(res.status).toBe(404);
-        expect(await res.json()).toEqual(BARE_NOT_FOUND);
+        expect(await res.json()).toEqual(TRANSPORT_NOT_FOUND);
         const notFoundOnRoot = await fetch(`${baseUrl}/totally/unrouted`);
         expect(notFoundOnRoot.status).toBe(404);
         expect(queries, 'the endpoint step ran for a path outside `/api/v1/apps/`').toEqual([]);
@@ -231,9 +241,16 @@ describe('matcher present — the endpoint dispatch step (#5090)', () => {
         const res = await fetch(`${baseUrl}/api/v1/apps/showcase/tasks`, { method: 'DELETE' });
         expect(res.status).toBe(405);
         expect(res.headers.get('Allow')).toBe('PUT');
-        const body = await res.json() as { code: string; allowed: string[] };
-        expect(body.code).toBe('METHOD_NOT_ALLOWED');
-        expect(body.allowed).toEqual(['PUT']);
+        // The adapter's 405, in the declared envelope since #9364 — `code` and
+        // the `allowed` hint moved from top-level siblings into `error` and
+        // `error.details` respectively. Same two facts, one level in.
+        const body = await res.json() as {
+            success: boolean;
+            error: { code: string; details: { allowed: string[] } };
+        };
+        expect(body.success).toBe(false);
+        expect(body.error.code).toBe('METHOD_NOT_ALLOWED');
+        expect(body.error.details.allowed).toEqual(['PUT']);
     });
 
     it('answers an execution result, never the "nothing was wired" 501', async () => {
@@ -518,11 +535,11 @@ describe('the wired chain — policies, then the real pipeline (#5129)', () => {
         queries.length = 0;
         const outside = await fetch(`${baseUrl}/api/v1/nope`);
         expect(outside.status).toBe(404);
-        expect(await outside.json()).toEqual(BARE_NOT_FOUND);
+        expect(await outside.json()).toEqual(TRANSPORT_NOT_FOUND);
 
         const missUnderMount = await fetch(`${baseUrl}/api/v1/apps/showcase/not-declared`);
         expect(missUnderMount.status).toBe(404);
-        expect(await missUnderMount.json()).toEqual(BARE_NOT_FOUND);
+        expect(await missUnderMount.json()).toEqual(TRANSPORT_NOT_FOUND);
 
         expect(queries).toEqual([{ path: '/api/v1/apps/showcase/not-declared', method: 'GET' }]);
     });

packages/runtime/src/dispatcher-plugin.multi-tenant-endpoint.integration.test.ts

@@ -256,11 +256,14 @@ describe('#5040 E5b — multi-tenant resolution finds no environment: decline +
         // single-environment host that never had a resolver.
         expect(resolverCalls).toEqual([undefined]);
 
-        // Declining writes nothing, so the bare Hono 404 stands. The host
+        // Declining writes nothing, so the transport's own 404 stands. The host
         // DECLARES this path and could have served it: without the branch this
         // is a 200 carrying `servedBy: 'host'`.
         expect(res.status).toBe(404);
-        expect(await res.json()).toEqual({ error: 'Not found' });
+        expect(await res.json()).toEqual({
+            success: false,
+            error: { code: 'ENDPOINT_NOT_FOUND', message: 'Not found' },
+        });
 
         // The decline happened BEFORE the probe. A declaration must never be
         // consulted for a request that was not placed in an environment.
@@ -284,7 +287,10 @@ describe('#5040 E5b — multi-tenant resolution finds no environment: decline +
 
         expect(resolverCalls).toEqual(['env-does-not-exist']);
         expect(res.status).toBe(404);
-        expect(await res.json()).toEqual({ error: 'Not found' });
+        expect(await res.json()).toEqual({
+            success: false,
+            error: { code: 'ENDPOINT_NOT_FOUND', message: 'Not found' },
+        });
         expect(matchQueries).toEqual([]);
     }, 60_000);
 });

packages/runtime/src/dispatcher-plugin.ready.integration.test.ts

@@ -59,14 +59,17 @@ describe('GET /ready over a real HTTP server (integration)', () => {
     expect(body.data.status).toBe('ok');
   });
 
-  it('proves the harness mirrors prod: an unmounted path 404s with the Hono not-found body', async () => {
+  it('proves the harness mirrors prod: an unmounted path 404s with the adapter not-found body', async () => {
     // This is the exact response /ready produced BEFORE the fix. Asserting it
     // here shows the test would have failed against the old code (the /ready
     // assertion above would have returned this body), not passed vacuously.
     const res = await fetch(`${baseUrl}/api/v1/this-route-does-not-exist`);
     expect(res.status).toBe(404);
     const body = await res.json();
-    expect(body).toEqual({ error: 'Not found' });
+    expect(body).toEqual({
+        success: false,
+        error: { code: 'ENDPOINT_NOT_FOUND', message: 'Not found' },
+    });
   });
 
   it('returns 503 while the kernel is shutting down (drain signal)', async () => {

packages/runtime/src/mcp-skill-method-not-allowed.hono.integration.test.ts

@@ -25,6 +25,15 @@ import { createDispatcherPlugin } from './dispatcher-plugin.js';
  * `{success:false, error:{code, message, httpStatus}}` carrying the documented
  * message "Method not allowed — use GET".
  *
+ * ⚠️ The quoted body above is the shape MEASURED IN #7627, and the adapter no
+ * longer emits it: #9364 converted `unmatchedResponse()` onto the same declared
+ * envelope, nesting `method`/`path`/`allowed` under `error.details`. The defect
+ * this file guards is unchanged — the wrong DOOR answering — but the two doors
+ * are no longer told apart by envelope shape, only by which optional member
+ * each fills (`httpStatus` for the domain, `details` for the adapter). See the
+ * note on the negative case below; several assertions here had to move for
+ * exactly that reason, and would otherwise have gone quietly vacuous.
+ *
  * ## Why the defect was invisible to the existing tests
  *
  * The 405 branch is NOT missing. `handleMcpSkillRequest` has had one since
@@ -146,13 +155,23 @@ describe('POST /api/v1/mcp/skill answers the standard 405 envelope (integration,
     it('POST does not answer with `unmatchedResponse()`\'s shape', async () => {
         const { body } = await call('POST');
 
-        // The four keys that identify the adapter's unmatched-route answer.
-        // `error` as a STRING is the tell — the standard envelope nests an
-        // object there, so this assertion cannot be satisfied by both shapes.
-        expect(typeof body.error).not.toBe('string');
-        expect(body).not.toHaveProperty('method');
-        expect(body).not.toHaveProperty('path');
-        expect(body).not.toHaveProperty('allowed');
+        // ⚠️ The tell CHANGED with #9364, and the old one would now pass
+        // vacuously. Before that card the adapter's 405 answered
+        // `error: 'Method Not Allowed'` (a STRING) with `method`/`path`/
+        // `allowed` as TOP-LEVEL siblings, so `typeof body.error !== 'string'`
+        // and three `not.toHaveProperty` checks genuinely separated the two
+        // doors. #9364 put the adapter's refusal into the same declared
+        // envelope, nesting its context under `error.details` — so all four of
+        // those assertions are now true of the ADAPTER answer as well, and
+        // would keep this test green in exactly the world it exists to catch.
+        //
+        // What still separates the doors is which OPTIONAL member each fills:
+        // the dispatcher's `buildApiError` carries `httpStatus` and no
+        // `details`; the adapter's `unmatchedResponse` carries
+        // `details.{method,path,allowed}` and no `httpStatus`. Both halves are
+        // asserted here so this case discriminates on its own.
+        expect(body.error).not.toHaveProperty('details');
+        expect(body.error.httpStatus).toBe(405);
     });
 
     // The `Allow` header CHANGES with this fix, which is worth stating exactly
@@ -201,6 +220,21 @@ describe('POST /api/v1/mcp/skill answers the standard 405 envelope (integration,
     it('PUT — unmounted — still falls through to the adapter (boundary, not a regression)', async () => {
         const { res, body } = await call('PUT');
         expect(res.status).toBe(405);
-        expect(body).toHaveProperty('allowed');
+
+        // The adapter's own 405. Since #9364 it speaks the SAME declared
+        // envelope as the domain branch, so `success`/`error.code` no longer
+        // tell the two apart — `error.details.allowed` is what does, and it is
+        // the direct successor of the top-level `allowed` this case used to
+        // read. Asserted by VALUE, not by presence — and the value is the
+        // whole four-verb set because #7649's fix mounts GET/POST/DELETE, with
+        // Hono registering HEAD implicitly alongside GET. That is precisely
+        // why PUT is the boundary probe: it is the one verb left unmounted.
+        expect(body.error.code).toBe('METHOD_NOT_ALLOWED');
+        expect(body.error.details.allowed).toEqual(['DELETE', 'GET', 'HEAD', 'POST']);
+        expect(body.error.details.method).toBe('PUT');
+        expect(body.error.details.path).toBe(SKILL_PATH);
+        // …and it is NOT the domain branch's answer, which fills `httpStatus`
+        // and no `details`.
+        expect(body.error).not.toHaveProperty('httpStatus');
     });
 });