deepdebug-local-agent 1.2.0 → 1.4.0

package/test/contract/la-protocol-v2/vectors/webhook.forward.vectors.json

@@ -0,0 +1,170 @@
+{
+  "type": "webhook.forward",
+  "schema": "webhook.forward.schema.json",
+  "vectors": [
+    {
+      "name": "minimal-valid",
+      "expect": {
+        "valid": true
+      },
+      "message": {
+        "schemaVersion": 2,
+        "type": "webhook.forward",
+        "msgId": "00000000-0000-4000-8000-000000000001",
+        "seq": 1,
+        "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+        "workspaceId": "ws-1",
+        "ts": "2026-10-29T10:00:00Z",
+        "paramsRaw": "{\"webhookId\":\"d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80\",\"source\":\"sentry\",\"contentType\":\"application/json\",\"bodyB64\":\"SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ=\"}",
+        "sig": {
+          "keyId": "vh-cp-2026-10",
+          "timestamp": "1793268000",
+          "nonce": "Zm9vYmFyYmF6cXV4MTIzNDU2",
+          "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+          "workspaceId": "ws-1",
+          "signature": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+        },
+        "payload": {
+          "webhookId": "d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80",
+          "source": "sentry",
+          "contentType": "application/json",
+          "bodyB64": "SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ="
+        }
+      }
+    },
+    {
+      "name": "extra-top-level-field",
+      "why": "envelope is closed (additionalProperties:false)",
+      "expect": {
+        "valid": false,
+        "code": "schema_violation",
+        "keyword": "additionalProperties"
+      },
+      "message": {
+        "schemaVersion": 2,
+        "type": "webhook.forward",
+        "msgId": "00000000-0000-4000-8000-000000000001",
+        "seq": 1,
+        "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+        "workspaceId": "ws-1",
+        "ts": "2026-10-29T10:00:00Z",
+        "paramsRaw": "{\"webhookId\":\"d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80\",\"source\":\"sentry\",\"contentType\":\"application/json\",\"bodyB64\":\"SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ=\"}",
+        "sig": {
+          "keyId": "vh-cp-2026-10",
+          "timestamp": "1793268000",
+          "nonce": "Zm9vYmFyYmF6cXV4MTIzNDU2",
+          "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+          "workspaceId": "ws-1",
+          "signature": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+        },
+        "payload": {
+          "webhookId": "d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80",
+          "source": "sentry",
+          "contentType": "application/json",
+          "bodyB64": "SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ="
+        },
+        "extra": "x"
+      }
+    },
+    {
+      "name": "extra-payload-field",
+      "why": "payload is closed: no free-form fields",
+      "expect": {
+        "valid": false,
+        "code": "schema_violation",
+        "keyword": "additionalProperties"
+      },
+      "message": {
+        "schemaVersion": 2,
+        "type": "webhook.forward",
+        "msgId": "00000000-0000-4000-8000-000000000001",
+        "seq": 1,
+        "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+        "workspaceId": "ws-1",
+        "ts": "2026-10-29T10:00:00Z",
+        "paramsRaw": "{\"webhookId\":\"d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80\",\"source\":\"sentry\",\"contentType\":\"application/json\",\"bodyB64\":\"SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ=\"}",
+        "sig": {
+          "keyId": "vh-cp-2026-10",
+          "timestamp": "1793268000",
+          "nonce": "Zm9vYmFyYmF6cXV4MTIzNDU2",
+          "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+          "workspaceId": "ws-1",
+          "signature": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+        },
+        "payload": {
+          "webhookId": "d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80",
+          "source": "sentry",
+          "contentType": "application/json",
+          "bodyB64": "SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ=",
+          "freeText": "client text"
+        }
+      }
+    },
+    {
+      "name": "tenant-id-not-uuid",
+      "why": "tenantId must be a UUID",
+      "expect": {
+        "valid": false,
+        "code": "schema_violation",
+        "keyword": "pattern"
+      },
+      "message": {
+        "schemaVersion": 2,
+        "type": "webhook.forward",
+        "msgId": "00000000-0000-4000-8000-000000000001",
+        "seq": 1,
+        "tenantId": "tenant-1",
+        "workspaceId": "ws-1",
+        "ts": "2026-10-29T10:00:00Z",
+        "paramsRaw": "{\"webhookId\":\"d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80\",\"source\":\"sentry\",\"contentType\":\"application/json\",\"bodyB64\":\"SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ=\"}",
+        "sig": {
+          "keyId": "vh-cp-2026-10",
+          "timestamp": "1793268000",
+          "nonce": "Zm9vYmFyYmF6cXV4MTIzNDU2",
+          "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+          "workspaceId": "ws-1",
+          "signature": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+        },
+        "payload": {
+          "webhookId": "d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80",
+          "source": "sentry",
+          "contentType": "application/json",
+          "bodyB64": "SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ="
+        }
+      }
+    },
+    {
+      "name": "body-above-limit",
+      "why": "v2.0 forwards bodies up to 9 KiB raw",
+      "expect": {
+        "valid": false,
+        "code": "schema_violation",
+        "keyword": "maxLength"
+      },
+      "message": {
+        "schemaVersion": 2,
+        "type": "webhook.forward",
+        "msgId": "00000000-0000-4000-8000-000000000001",
+        "seq": 1,
+        "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+        "workspaceId": "ws-1",
+        "ts": "2026-10-29T10:00:00Z",
+        "paramsRaw": "{\"webhookId\":\"d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80\",\"source\":\"sentry\",\"contentType\":\"application/json\",\"bodyB64\":\"SGVsbG8gZnJvbSB0aGUgTG9jYWwgQWdlbnQ=\"}",
+        "sig": {
+          "keyId": "vh-cp-2026-10",
+          "timestamp": "1793268000",
+          "nonce": "Zm9vYmFyYmF6cXV4MTIzNDU2",
+          "tenantId": "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f",
+          "workspaceId": "ws-1",
+          "signature": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+        },
+        "payload": {
+          "webhookId": "d4e5f6a7-b8c9-4d0e-9f1a-3b4c5d6e7f80",
+          "source": "sentry",
+          "contentType": "application/json",
+          "bodyB64": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        }
+      }
+    }
+  ]
+}

package/test/la-protocol-v2/contract.test.js

@@ -0,0 +1,131 @@
+// F3-05b: the contract as the Local Agent applies it. Every vector of the gateway's F3-22 suite (valid AND
+// invalid) must be classified the way the vector declares, the copy must be the gateway's, and the
+// tables the LA keeps by hand (error codes, fatal set) must match the schema.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadContract } from "../../src/la-protocol-v2/contract.js";
+import { ERROR_CODES, closeCodeOf, isFatal, isRetryable } from "../../src/la-protocol-v2/errors.js";
+import { parseStrict } from "../../src/la-protocol-v2/strict-json.js";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const RUNTIME = path.join(ROOT, "src/la-protocol-v2/contract");
+const VECTORS = path.join(ROOT, "test/contract/la-protocol-v2/vectors");
+const contract = loadContract();
+const sha = (b) => crypto.createHash("sha256").update(b).digest("hex");
+
+test("the copy is the gateway's: CONTRACT_SOURCE.json hashes every file and names the commit", () => {
+    const src = JSON.parse(fs.readFileSync(path.join(RUNTIME, "CONTRACT_SOURCE.json"), "utf8"));
+    assert.match(src.commit, /^[0-9a-f]{40}$/);
+    assert.equal(src.repo, "VISIONHAMMER/vh-api-gateway");
+    let n = 0;
+    for (const [rel, hash] of Object.entries(src.files)) {
+        const file = rel.startsWith("vectors/") ? path.join(ROOT, "test/contract/la-protocol-v2", rel) : path.join(RUNTIME, rel);
+        assert.equal(sha(fs.readFileSync(file)), hash, `${rel} was edited after the sync`);
+        n++;
+    }
+    assert.ok(n >= 60, `expected the schemas and all vectors, got ${n}`);
+    // nothing extra sneaked in next to the copy
+    const onDisk = fs.readdirSync(RUNTIME).filter((f) => f !== "CONTRACT_SOURCE.json");
+    for (const f of onDisk) assert.ok(src.files[f], `${f} is not part of the synced contract`);
+});
+
+test("VH_GATEWAY_CONTRACT_DIR (optional): the copy equals a gateway checkout byte for byte", { skip: !process.env.VH_GATEWAY_CONTRACT_DIR }, () => {
+    const dir = process.env.VH_GATEWAY_CONTRACT_DIR;
+    for (const f of fs.readdirSync(dir).filter((n) => n.endsWith(".schema.json") || n === "index.json")) {
+        assert.equal(sha(fs.readFileSync(path.join(dir, f))), sha(fs.readFileSync(path.join(RUNTIME, f))), f);
+    }
+});
+
+// ------------------------------------------------------------------------------------------------ vectors
+
+const vectorFiles = fs.readdirSync(VECTORS).filter((f) => f.endsWith(".vectors.json"));
+
+test("vectors: the suite is complete (every type has a file, plus cross-type)", () => {
+    const types = Object.keys(contract.index.types);
+    for (const t of types) assert.ok(vectorFiles.includes(`${t}.vectors.json`), `no vectors for ${t}`);
+    assert.ok(vectorFiles.includes("cross-type.vectors.json"));
+});
+
+let valid = 0;
+let invalid = 0;
+for (const file of vectorFiles) {
+    const doc = JSON.parse(fs.readFileSync(path.join(VECTORS, file), "utf8"));
+    for (const v of doc.vectors) {
+        test(`vector ${file.replace(".vectors.json", "")} :: ${v.name}`, () => {
+            const r = contract.validateFrame(v.message);
+            if (v.expect.valid) {
+                valid++;
+                assert.equal(r.ok, true, `expected valid, got ${r.code} ${r.keywords}`);
+                return;
+            }
+            invalid++;
+            assert.equal(r.ok, false, "expected the frame to be refused");
+            // payload_too_large is the session-level refinement of schema_violation for maxLength under /payload (gateway rule)
+            const refined = v.expect.code === "schema_violation" && r.code === "payload_too_large" && r.keywords.includes("maxLength");
+            assert.ok(r.code === v.expect.code || refined, `code ${r.code} != ${v.expect.code}`);
+            if (v.expect.keyword) assert.ok(r.keywords.includes(v.expect.keyword), `keyword ${v.expect.keyword} not in ${r.keywords}`);
+            if (v.expect.rule) assert.ok(r.rules.includes(v.expect.rule), `rule ${v.expect.rule} not in ${r.rules}`);
+        });
+    }
+}
+
+test("vectors: counts (134 = 24 valid + 110 invalid in this copy)", () => {
+    assert.equal(valid + invalid, 134);
+    assert.equal(valid, 24);
+    assert.equal(invalid, 110);
+});
+
+// ------------------------------------------------------------------------------------------------ tables
+
+test("error codes: the LA table is the schema enum, in the same order; close code = 4400 + position (timeout = 4420)", () => {
+    assert.deepEqual([...ERROR_CODES], contract.errorCodes);
+    assert.equal(closeCodeOf("timeout"), 4420);
+    assert.equal(closeCodeOf("bad_frame"), 4400);
+    for (const c of ERROR_CODES) {
+        const cc = closeCodeOf(c);
+        assert.ok(cc >= 4400 && cc <= 4499, c);
+    }
+});
+
+test("error codes: fatal and retryable sets mirror the gateway (LaV2ErrorCode)", () => {
+    const nonFatal = ERROR_CODES.filter((c) => !isFatal(c)).sort();
+    assert.deepEqual(nonFatal, ["agent_offline", "internal", "protocol_unsupported", "rate_limited", "timeout"]);
+    assert.deepEqual(ERROR_CODES.filter(isRetryable).sort(), ["agent_offline", "internal", "rate_limited", "seq_gap", "timeout"]);
+});
+
+test("allowlist: the LA receives only cp->la/both types and sends only la->cp/both types; v1 commands are not types", () => {
+    assert.deepEqual([...contract.inboundTypes].sort(), ["ack", "approval.decision", "config.update", "content.request", "error", "job.assign", "job.cancel", "ready", "scan.upload", "webhook.forward"]);
+    assert.deepEqual([...contract.outboundTypes].sort(), ["ack", "alert", "audit.event", "content.response", "error", "heartbeat", "hello", "incident.candidate", "job.event", "job.result", "log.stats", "register", "scan.uploaded"]);
+    for (const v1 of ["mcp.execute-command", "workspace.open", "health", "shell.exec", "__proto__", "constructor", "toString"]) {
+        assert.equal(contract.canReceive(v1), false, v1);
+        assert.equal(contract.canSend(v1), false, v1);
+    }
+});
+
+test("limits come from index.json and are the documented ones", () => {
+    assert.deepEqual({ ...contract.limits }, {
+        maxFrameBytes: 49152, chunkRawBytes: 32768, maxChunks: 64, maxContentBytes: 2097152, maxRetries: 3, ackTimeoutMs: 5000,
+        handshakeTimeoutMs: 10000, heartbeatSeconds: 30, sessionDeadSeconds: 90, dedupeWindowSeconds: 600, clockSkewSeconds: 60,
+    });
+});
+
+// ------------------------------------------------------------------------------------------------ strict JSON
+
+test("parseStrict: valid JSON is returned as JSON.parse would", () => {
+    assert.deepEqual(parseStrict('{"a":1,"b":{"c":[1,2,{"d":"x,\\"y\\":z"}]},"e":"{\\"a\\":1,\\"a\\":2}"}'), { a: 1, b: { c: [1, 2, { d: 'x,"y":z' }] }, e: '{"a":1,"a":2}' });
+});
+test("parseStrict: a duplicate key at any depth is refused", () => {
+    assert.throws(() => parseStrict('{"a":1,"a":2}'));
+    assert.throws(() => parseStrict('{"x":{"a":1,"b":2,"a":3}}'));
+    assert.throws(() => parseStrict('[{"k":1},{"k":2,"k":3}]'));
+    assert.doesNotThrow(() => parseStrict('[{"k":1},{"k":2}]'));
+    assert.doesNotThrow(() => parseStrict('{"a":{"k":1},"b":{"k":2}}'));
+});
+test("parseStrict: invalid JSON throws", () => {
+    assert.throws(() => parseStrict("{"));
+    assert.throws(() => parseStrict("not json"));
+});

package/test/la-protocol-v2/helpers/la-rig.js

@@ -0,0 +1,83 @@
+// A miniature of the v1 tunnel in server.js, around the REAL v2 link: opens a ws to a ReferenceCpServer,
+// hands the socket to the link exactly like server.js does, and records what the v1 handler would get.
+import WebSocket from "ws";
+import { createV2Link } from "../../../src/la-protocol-v2/link.js";
+import { resolveSigningConfig } from "../../../src/utils/request-signing.js";
+import { TENANT, AGENT } from "./reference-cp.js";
+
+export function signingFor(server, mode = "enforce", extraEnv = {}) {
+    return resolveSigningConfig({
+        LOCAL_AGENT_SIGNATURE_MODE: mode,
+        LOCAL_AGENT_SIGNING_PUBLIC_KEYS: `${server.keyId}=${server.publicKeyRaw}`,
+        LOCAL_AGENT_TENANT_ID: TENANT,
+        ...extraEnv,
+    }, { defaultFile: null, fileCfg: {} });
+}
+
+export function startRig(server, { mode = "enforce", sessionOptions = {}, options = {}, fallbackMs = 600_000, tenantId = TENANT, agentId = AGENT } = {}) {
+    const logs = [];
+    const log = { info: (m) => logs.push(m), log: (m) => logs.push(m), warn: (m) => logs.push(m) };
+    const signing = signingFor(server, mode);
+    const link = createV2Link({
+        log, fallbackMs,
+        sessionOptions: {
+            tenantId, agentId, signing, laVersion: "1.3.0", capabilities: ["protocol.v2", "v1.commands", "chunk.base64"],
+            getWorkspaces: () => [{ workspaceId: "ws-1", pathSha256: "ab".repeat(32) }],
+            getHealth: () => ({ diskFreeBytes: 1234 }),
+            options: { handshakeTimeoutMs: 400, ...options },
+            ...sessionOptions,
+        },
+    });
+    const rig = {
+        link, session: link.session, logs, signing,
+        v1Messages: [],          // texts that reached the v1 handler (the tunnel's existing code)
+        inbound: [],             // every text received from the CP, in order
+        legacyRegisters: 0,
+        ws: null,
+        connect() {
+            return new Promise((resolve) => {
+                const ws = new WebSocket(`ws://127.0.0.1:${server.port}/api/v1/agent/ws`, { headers: { Authorization: `Bearer ${server.token}` } });
+                rig.ws = ws;
+                ws.on("open", () => {
+                    const legacy = () => { rig.legacyRegisters++; ws.send(JSON.stringify({ type: "register", tenantId, port: 5055, workspacePath: null })); };
+                    if (!link.begin(ws, legacy)) legacy();
+                    resolve(ws);
+                });
+                ws.on("message", (data, isBinary) => {
+                    const text = data.toString();
+                    if (text === "pong") return;
+                    rig.inbound.push(text);
+                    if (link.handleMessage(ws, text, isBinary)) return;
+                    rig.v1Messages.push(text);
+                });
+                ws.on("close", () => link.onClose(ws));
+                ws.on("error", () => {});
+            });
+        },
+        drop() { rig.ws && rig.ws.terminate(); },
+        async stop() { rig.ws && rig.ws.terminate(); link.close(); },
+    };
+    return rig;
+}
+
+/** No sockets: the session's transport writes straight into a ReferenceCp and the CP's frames straight into the session. */
+import { V2Session } from "../../../src/la-protocol-v2/session.js";
+export function inMemory(cp, { mode = "enforce", tenantId = TENANT, agentId = AGENT, options = {}, sessionOptions = {}, signing } = {}) {
+    const logs = [];
+    const session = new V2Session({
+        tenantId, agentId, signing: signing || signingFor({ keyId: cp.keyId, publicKeyRaw: cp.publicKeyRaw }, mode),
+        laVersion: "1.3.0", capabilities: ["protocol.v2", "v1.commands", "chunk.base64"],
+        getWorkspaces: () => [{ workspaceId: "ws-1", pathSha256: "ab".repeat(32) }],
+        getHealth: () => ({ diskFreeBytes: 1234 }),
+        log: { info: (m) => logs.push(m), warn: (m) => logs.push(m) },
+        options: { handshakeTimeoutMs: 400, ...options }, ...sessionOptions,
+    });
+    const wire = { toLa: [], toCp: [], closed: [], cpClosed: [] };
+    const transport = {
+        send: (t) => { wire.toCp.push(t); cp.feed(t); },
+        close: (c, r) => { wire.closed.push([c, r]); },
+        bufferedAmount: () => 0,
+    };
+    cp.attach((t) => { wire.toLa.push(t); queueMicrotask(() => session.handleText(t, transport)); }, (c, r) => wire.cpClosed.push([c, r]));
+    return { session, transport, wire, logs, start() { session.attach(transport); return this; } };
+}